@talkpilot/core-db 1.3.51 → 1.3.52

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

@@ -0,0 +1,329 @@
+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

@@ -0,0 +1,45 @@
+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/index.ts

@@ -1,4 +1,5 @@
 export * from "./talkpilot/agents";
+export * from "./talkpilot/clients";
 export * from "./talkpilot/calls";
 export * from "./talkpilot/clientAudioBuffers";
 export * from "./talkpilot/clientsConfig";
@@ -7,6 +8,7 @@ export * from "./talkpilot/contextNotes";
 export * from "./talkpilot/groups";
 export * from "./talkpilot/phone_numbers";
 export * from "./talkpilot/sessions";
+export * from "./talkpilot/results";
 export * from "./municipal/cities";
 export * from "./municipal/departmentsSubjects";
 export * from "./municipal/muniIssues";

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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,43 @@
+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);
+}

package/src/websitalk/scanResources/__tests__/scanResources.spec.ts

@@ -5,7 +5,6 @@ import {
   getScanPages,
   getScanResourceById,
   getScanResourceCountsByScanIds,
-  deleteScanResourcesByScanId,
 } from "../scanResources.getters";
 import { boardColumn } from "../scanResources.utils";
 import { createScanResourceFixture } from "../../../test-utils/factories";
@@ -191,22 +190,4 @@ describe("db.websitalk.scanResources", () => {
       expect(result).toBeNull();
     });
   });
-
-  describe("deleteScanResourcesByScanId()", () => {
-    it("should delete all resources for the scan and return the count", async () => {
-      const scanId = new ObjectId().toString();
-      await getScanResourcesCollection().insertMany([
-        createScanResourceFixture({ scanId }),
-        createScanResourceFixture({ scanId }),
-        createScanResourceFixture({ scanId: new ObjectId().toString() }),
-      ]);
-
-      const deleted = await deleteScanResourcesByScanId(scanId);
-
-      expect(deleted).toBe(2);
-      expect(
-        await getScanResourcesCollection().countDocuments({ scanId }),
-      ).toBe(0);
-    });
-  });
 });

package/src/websitalk/scanResources/scanResources.getters.ts

@@ -100,10 +100,3 @@ export const getScanResourceById = async (
   pageId: string,
 ): Promise<ScanResourceDoc | null> =>
   getScanResourcesCollection().findOne({ scanId, _id: new ObjectId(pageId) });
-
-export const deleteScanResourcesByScanId = async (
-  scanId: string,
-): Promise<number> => {
-  const result = await getScanResourcesCollection().deleteMany({ scanId });
-  return result.deletedCount;
-};

package/src/websitalk/scans/__tests__/scans.spec.ts

@@ -12,7 +12,6 @@ import {
   getInProgressScanByWebsiteUrl,
   getLatestCompletedScanByWebsiteUrl,
   deleteScansByWebsiteUrl,
-  deleteScanById,
 } from "../scans.getters";
 import { createScanFixture } from "../../../test-utils/factories";
 import { ObjectId } from "mongodb";
@@ -311,20 +310,4 @@ describe("db.websitalk.scans", () => {
       expect(await countScans({ websiteUrlId })).toBe(0);
     });
   });
-
-  describe("deleteScanById()", () => {
-    it("should delete the scan and return true", async () => {
-      const { insertedId } =
-        await getScansCollection().insertOne(createScanFixture());
-
-      expect(await deleteScanById(insertedId)).toBe(true);
-      expect(
-        await getScansCollection().findOne({ _id: insertedId }),
-      ).toBeNull();
-    });
-
-    it("should return false when the scan does not exist", async () => {
-      expect(await deleteScanById(new ObjectId())).toBe(false);
-    });
-  });
 });

package/src/websitalk/scans/scans.constants.ts

@@ -6,7 +6,6 @@ export const SCAN_STATUSES = {
   COMPLETED: "COMPLETED",
   FAILED: "FAILED",
   OVERWRITTEN: "OVERWRITTEN",
-  PAUSED: "PAUSED",
 } as const;
 
 export const FINISHED_SCAN_STATUSES = [

package/src/websitalk/scans/scans.getters.ts

@@ -164,8 +164,3 @@ export const deleteScansByWebsiteUrl = async (
   const result = await getScansCollection().deleteMany({ websiteUrlId });
   return result.deletedCount;
 };
-
-export const deleteScanById = async (scanId: ObjectId): Promise<boolean> => {
-  const result = await getScansCollection().deleteOne({ _id: scanId });
-  return result.deletedCount > 0;
-};