@talkpilot/core-db 1.3.50 → 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/talkpilot/results/results.types.ts

@@ -1,34 +1,34 @@
-import { ObjectId } from "mongodb";
-
-export interface Result {
-  _id?: ObjectId;
-  calls: CallResult[];
-  clientId: string;
-  date: Date;
-  runId: string;
-  sessionId: ObjectId | string;
-  sessionName: string;
-}
-
-export interface CallResult {
-  callSid: string;
-  status: string;
-  date: Date;
-  statuses: string[];
-  userAnswer: string | null;
-  color: string | null;
-  name: string | null;
-  callLength: string;
-  answeredBy: string | null;
-  to: string;
-  from: string;
-  transcription: TranscriptionSegment[];
-  flowId: ObjectId | string;
-  recordingUrl: string | null;
-  agentHungUp?: boolean;
-  endReason?: string;
-}
-
-export type TranscriptionSegment =
-  | { assistant: string; user?: never }
-  | { user: string; assistant?: never };
+import { ObjectId } from "mongodb";
+
+export interface Result {
+  _id?: ObjectId;
+  calls: CallResult[];
+  clientId: string;
+  date: Date;
+  runId: string;
+  sessionId: ObjectId | string;
+  sessionName: string;
+}
+
+export interface CallResult {
+  callSid: string;
+  status: string;
+  date: Date;
+  statuses: string[];
+  userAnswer: string | null;
+  color: string | null;
+  name: string | null;
+  callLength: string;
+  answeredBy: string | null;
+  to: string;
+  from: string;
+  transcription: TranscriptionSegment[];
+  flowId: ObjectId | string;
+  recordingUrl: string | null;
+  agentHungUp?: boolean;
+  endReason?: string;
+}
+
+export type TranscriptionSegment =
+  | { assistant: string; user?: never }
+  | { user: string; assistant?: never };