@talkpilot/core-db 1.2.0 → 1.2.2

package/src/talkpilot/calls/calls.getters.ts

@@ -1,446 +1,248 @@
-import {
-  Call,
-  CallDoc,
-  CallQueryOptions,
-  CallUpdateParams,
-  getDb,
-} from "../index";
-import type { CallsByHour, CountOpts, DateRange, ToolExecution,HourlyBucket,DailyBucket,CallLengthBuckets,DashboardKpis,DashboardCharts,RecentCall,DashboardStatsResult, DashboardStatsParams } from "./calls.types";
-import { Filter, ObjectId } from "mongodb";
-import * as process from "node:process";
-import { applyQueryOptions } from "../utils/query.utils";
-
-const TIMEZONE = 'UTC';
-
-export const getCallsCollection = () => {
-  return getDb().collection<Call>("calls");
-};
-
-export const getCallByCallSid = (callSid: string) => {
-  return getCallsCollection().findOne({ callSid });
-};
-
-export const getCallsByPhoneNumber = (phoneNumber: string) => {
-  return getCallsCollection()
-    .find({ customerPhoneNumber: phoneNumber })
-    .toArray();
-};
-
-export const getCallsByClient = (clientId: string) => {
-  return getCallsCollection().find({ clientId }).toArray();
-};
-
-export const getCallsByFlow = (flowId: ObjectId) => {
-  return getCallsCollection().find({ flowId }).toArray();
-};
-
-export const createCallDoc = (
-  call: Omit<Call, "createdAt" | "updatedAt" | "env">,
-) => {
-  return getCallsCollection().insertOne({
-    ...call,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-    env: process.env.ENV ?? "unknown",
-  });
-};
-
-export const updateCallByCallSid = async (
-  callSid: string,
-  updates: CallUpdateParams,
-): Promise<CallDoc | null> => {
-  return await getCallsCollection().findOneAndUpdate(
-    { callSid: callSid },
-    {
-      $set: {
-        ...updates,
-        updatedAt: new Date(),
-      },
-    },
-    { returnDocument: "after" },
-  );
-};
-
-export const pushToolExecution = async (
-  callSid: string,
-  execution: ToolExecution
-): Promise<void> => {
-  await getCallsCollection().updateOne(
-    { callSid },
-    { $push: { toolExecutions: execution } }
-  );
-};
-
-// get calls by client and date range
-//client here is the user id
-export const getCallsByClientAndDateRange = (
-  clientId: string,
-  startDate: Date,
-  endDate: Date,
-) => {
-  return getCallsCollection()
-    .find({
-      clientId,
-      createdAt: {
-        $gte: startDate,
-        $lte: endDate,
-      },
-    })
-    .toArray();
-};
-
-export const findCallsByQuery = async (
-  query: Filter<Call>,
-  options?: CallQueryOptions,
-): Promise<CallDoc[]> => {
-  const cursor = getCallsCollection().find(query);
-  return await applyQueryOptions(cursor, options).toArray();
-};
-
-export const countCalls = async (query: Filter<Call>): Promise<number> => {
-  return getCallsCollection().countDocuments(query);
-};
-
-export async function countCallsByPhoneInRange(
-  customerPhoneNumber: string,
-  opts: CountOpts = {},
-  range: DateRange = {},
-): Promise<number> {
-  const filter: Partial<Call> & { customerPhoneNumber: string } = {
-    customerPhoneNumber,
-  };
-
-  if (opts.isOutgoingCall !== undefined) {
-    filter.isOutgoingCall = opts.isOutgoingCall;
-  }
-  if (opts.isIncomingCall !== undefined) {
-    filter.isIncomingCall = opts.isIncomingCall;
-  }
-
-  if (range.since || range.until) {
-    (filter as Filter<Call>).createdAt = {
-      ...(range.since ? { $gte: range.since } : {}),
-      ...(range.until ? { $lt: range.until } : {}),
-    };
-  }
-
-  return getCallsCollection().countDocuments(filter as Filter<Call>);
-}
-
-export const range = {
-  between: (since: Date, until: Date): DateRange => ({ since, until }),
-  todayToNow: (): DateRange => ({ since: startOfDay(), until: new Date() }),
-  yesterday: (): DateRange => {
-    const s = startOfDay(addDays(new Date(), -1));
-    const e = addDays(s, 1);
-    return { since: s, until: e };
-  },
-  todayFull: (): DateRange => {
-    const s = startOfDay();
-    const e = addDays(s, 1);
-    return { since: s, until: e };
-  },
-  startOfDayToNow: (d: Date): DateRange => ({
-    since: startOfDay(d),
-    until: new Date(),
-  }),
-};
-
-export function startOfDay(d: Date = new Date()): Date {
-  const x = new Date(d);
-  x.setUTCHours(0, 0, 0, 0);
-  return x;
-}
-
-export function addDays(d: Date, days: number): Date {
-  const x = new Date(d);
-  x.setDate(x.getDate() + days);
-  return x;
-}
-
-/**
- * Aggregate calls stats for a date range (createdAt in [startStr, endStr] in timezone).
- * completed = agentHungUp=true or status='completed'.
- */
-export async function getCallsStatsForDateRange(
-  clientId: string,
-  startStr: string,
-  endStr: string,
-  timezone: string,
-): Promise<{ count: number; totalLen: number; completed: number }> {
-  const coll = getCallsCollection();
-  const out = await coll
-    .aggregate<{
-      _id: null;
-      count: number;
-      totalLen: number;
-      completed: number;
-    }>([
-      // 1. Restrict to the given client
-      { $match: { clientId } },
-      // 2. Derive dateLocal (createdAt as YYYY-MM-DD in timezone) and isCompleted (agentHungUp or status='completed')
-      {
-        $addFields: {
-          dateLocal: {
-            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
-          },
-          isCompleted: {
-            $or: [
-              { $eq: ["$agentHungUp", true] },
-              { $eq: ["$status", "completed"] },
-            ],
-          },
-        },
-      },
-      // 3. Keep only documents with dateLocal in [startStr, endStr] (inclusive)
-      { $match: { dateLocal: { $gte: startStr, $lte: endStr } } },
-      // 4. Single group: count, totalLen, completed
-      {
-        $group: {
-          _id: null,
-          count: { $sum: 1 },
-          totalLen: { $sum: "$callLength" },
-          completed: { $sum: { $cond: ["$isCompleted", 1, 0] } },
-        },
-      },
-    ])
-    .next();
-  return {
-    count: out?.count ?? 0,
-    totalLen: out?.totalLen ?? 0,
-    completed: out?.completed ?? 0,
-  };
-}
-
-/**
- * Aggregate calls by hour for a given date (createdAt converted to given timezone). Hour format "HH:mm".
- */
-export async function getCallsHourlyAggregation(
-  clientId: string,
-  dateStr: string,
-  timezone: string,
-): Promise<CallsByHour[]> {
-  const coll = getCallsCollection();
-  const rows = await coll
-    .aggregate<{ _id: number; calls: number }>([
-      // 1. Restrict to the given client
-      { $match: { clientId } },
-      // 2. Derive dateLocal (createdAt as YYYY-MM-DD in timezone) and hour (0–23 from createdAt in timezone)
-      {
-        $addFields: {
-          dateLocal: {
-            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
-          },
-          hour: { $hour: { date: "$createdAt", timezone } },
-        },
-      },
-      // 3. Keep only the requested date
-      { $match: { dateLocal: dateStr } },
-      // 4. Group by hour, sum calls per hour
-      { $group: { _id: "$hour", calls: { $sum: 1 } } },
-      // 5. Order by hour ascending (0..23)
-      { $sort: { _id: 1 } },
-    ])
-    .toArray();
-
-  return rows.map((r: any) => ({
-    hour: `${String(r._id).padStart(2, "0")}:00`,
-    calls: r.calls,
-  }));
-}
-
-function buildKpisPipeline() {
-  return [
-    {
-      $group: {
-        _id: null,
-        totalCalls: { $sum: 1 },
-        totalDuration: { $sum: '$callLength' },
-        completedCount: {
-          $sum: { $cond: [{ $eq: ['$status', 'completed'] }, 1, 0] },
-        },
-        failedCount: {
-          $sum: { $cond: [{ $eq: ['$status', 'failed'] }, 1, 0] },
-        },
-        noAnswerCount: {
-          $sum: { $cond: [{ $eq: ['$status', 'no-answer'] }, 1, 0] },
-        },
-        busyCount: {
-          $sum: { $cond: [{ $eq: ['$status', 'busy'] }, 1, 0] },
-        },
-      },
-    },
-  ];
-}
-
-function buildDailyDataPipeline(timezone: string) {
-  return [
-    {
-      $group: {
-        _id: {
-          $dateToString: { format: '%Y-%m-%d', date: '$createdAt', timezone: timezone },
-        },
-        count: { $sum: 1 },
-        completed: {
-          $sum: { $cond: [{ $eq: ['$status', 'completed'] }, 1, 0] },
-        },
-      },
-    },
-    { $sort: { _id: 1 } },
-  ];
-}
-
-function buildHourlyDataPipeline(timezone: string) {
-  return [
-    {
-      $group: {
-        _id: {
-          day: { $dateToString: { format: '%Y-%m-%d', date: '$createdAt', timezone: timezone } },
-          hour: { $hour: { date: '$createdAt', timezone: timezone } },
-        },
-        count: { $sum: 1 },
-      },
-    },
-  ];
-}
-
-function buildCallLengthBucketsPipeline() {
-  return [
-    {
-      $group: {
-        _id: null,
-        short: { $sum: { $cond: [{ $lt: ['$callLength', 60] }, 1, 0] } },
-        medium: {
-          $sum: {
-            $cond: [
-              { $and: [{ $gte: ['$callLength', 60] }, { $lte: ['$callLength', 180] }] },
-              1,
-              0,
-            ],
-          },
-        },
-        long: { $sum: { $cond: [{ $gt: ['$callLength', 180] }, 1, 0] } },
-      },
-    },
-  ];
-}
-
-function buildRecentCallsPipeline() {
-  return [
-    { $sort: { createdAt: -1 } },
-    { $limit: 8 },
-    {
-      $project: {
-        callSid: 1,
-        customerPhoneNumber: 1,
-        status: 1,
-        callLength: 1,
-        createdAt: 1,
-        summary: 1,
-        isIncomingCall: 1,
-      },
-    },
-  ];
-}
-
-export async function getDashboardStats(
-  params: DashboardStatsParams,
-): Promise<DashboardStatsResult> {
-  const { clientId, startDate, endDate } = params;
-
-  const startDateObj = new Date(startDate);
-  const endDateObj = new Date(endDate);
-
-  const startStr = startDateObj.toISOString().slice(0, 10);
-  const endStr = endDateObj.toISOString().slice(0, 10);
-
-console.info('[core-db] Fetching dashboard stats', { clientId, startStr, endStr });
-  const pipeline = [
-    {
-      $match: {
-        clientId,
-        createdAt: { $gte: startDateObj, $lte: endDateObj },
-      },
-    },
-    {
-      $facet: {
-        kpis: buildKpisPipeline(),
-        dailyData: buildDailyDataPipeline(TIMEZONE),
-        hourlyData: buildHourlyDataPipeline(TIMEZONE), 
-        callLengthBuckets: buildCallLengthBucketsPipeline(),  
-        recentCalls: buildRecentCallsPipeline(),
-      },
-    },
-  ];
-
-  const callsCollection = getCallsCollection();
-  const [aggregatedResult] = await callsCollection.aggregate(pipeline).toArray();
-
-  const kpiData = aggregatedResult?.kpis?.[0] ?? {
-    totalCalls: 0,
-    totalDuration: 0,
-    completedCount: 0,
-    failedCount: 0,
-    noAnswerCount: 0,
-    busyCount: 0,
-  };
-  const dailyDataRaw = aggregatedResult?.dailyData ?? [];
-  const hourlyDataRaw = aggregatedResult?.hourlyData ?? [];
-  const callLengthRaw = aggregatedResult?.callLengthBuckets?.[0] ?? { short: 0, medium: 0, long: 0 };
-  const recentCallsRaw: RecentCall[] = aggregatedResult?.recentCalls ?? [];
-
-  const count = kpiData.totalCalls;
-  const totalLen = kpiData.totalDuration;
-  const completed = kpiData.completedCount;
-
-  const kpis: DashboardKpis = {
-    totalCalls: count,
-    avgDurationSeconds: count > 0 ? Math.round(totalLen / count) : 0,
-    timeSavedMinutes: Math.round(totalLen / 60),
-    successRate: count > 0 ? Math.round((completed / count) * 1000) / 10 : 0,
-    completedCount: completed,
-    failedCount: kpiData.failedCount,
-    noAnswerCount: kpiData.noAnswerCount,
-    busyCount: kpiData.busyCount,
-  };
-
-  const volumeData: DailyBucket[] = dailyDataRaw.map((d: any) => ({
-    date: d._id,
-    count: d.count,
-    completed: d.completed,
-  }));
-
-  const heatmapMap = new Map<string, Map<number, number>>();
-  for (const bucket of hourlyDataRaw) {
-    const dayKey = bucket._id.day;
-    const hour = bucket._id.hour;
-    if (!heatmapMap.has(dayKey)) heatmapMap.set(dayKey, new Map());
-    heatmapMap.get(dayKey)!.set(hour, bucket.count);
-  }
-
-  const toSortedBuckets = (map: Map<number, number>): HourlyBucket[] =>
-    Array.from(map.entries())
-      .sort(([a], [b]) => a - b)
-      .map(([h, c]) => ({ hour: `${String(h).padStart(2, '0')}:00`, calls: c }));
-
-  const heatmap: Record<string, HourlyBucket[]> = {};
-  for (const [day, hourMap] of Array.from(heatmapMap.entries()).sort()) {
-    heatmap[day] = toSortedBuckets(hourMap);
-  }
-
-  return {
-    kpis,
-    charts: {
-      volumeData,
-      heatmap,
-      callLengthBuckets: {
-        short: callLengthRaw.short,
-        medium: callLengthRaw.medium,
-        long: callLengthRaw.long,
-      },
-    },
-    recentCalls: recentCallsRaw,
-  };
-}
-
-
+import {
+  Call,
+  CallDoc,
+  CallQueryOptions,
+  CallUpdateParams,
+  getDb,
+} from "../index";
+import type { CountOpts, DateRange, ToolExecution } from "./calls.types";
+import { Filter, ObjectId } from "mongodb";
+import * as process from "node:process";
+import { applyQueryOptions } from "../utils/query.utils";
+import { DashboardHeatmapMetric } from "./dashboard/calls.dashboard.types";
+
+export const getCallsCollection = () => {
+  return getDb().collection<Call>("calls");
+};
+
+export const getCallByCallSid = (callSid: string) => {
+  return getCallsCollection().findOne({ callSid });
+};
+
+export const getCallsByPhoneNumber = (phoneNumber: string) => {
+  return getCallsCollection()
+    .find({ customerPhoneNumber: phoneNumber })
+    .toArray();
+};
+
+export const getCallsByClient = (clientId: string) => {
+  return getCallsCollection().find({ clientId }).toArray();
+};
+
+export const getCallsByFlow = (flowId: ObjectId) => {
+  return getCallsCollection().find({ flowId }).toArray();
+};
+
+export const createCallDoc = (
+  call: Omit<Call, "createdAt" | "updatedAt" | "env">,
+) => {
+  return getCallsCollection().insertOne({
+    ...call,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    env: process.env.ENV ?? "unknown",
+  });
+};
+
+export const updateCallByCallSid = async (
+  callSid: string,
+  updates: CallUpdateParams,
+): Promise<CallDoc | null> => {
+  return await getCallsCollection().findOneAndUpdate(
+    { callSid: callSid },
+    {
+      $set: {
+        ...updates,
+        updatedAt: new Date(),
+      },
+    },
+    { returnDocument: "after" },
+  );
+};
+
+export const pushToolExecution = async (
+  callSid: string,
+  execution: ToolExecution,
+): Promise<void> => {
+  await getCallsCollection().updateOne(
+    { callSid },
+    { $push: { toolExecutions: execution } },
+  );
+};
+
+// get calls by client and date range
+//client here is the user id
+export const getCallsByClientAndDateRange = (
+  clientId: string,
+  startDate: Date,
+  endDate: Date,
+) => {
+  return getCallsCollection()
+    .find({
+      clientId,
+      createdAt: {
+        $gte: startDate,
+        $lte: endDate,
+      },
+    })
+    .toArray();
+};
+
+export const findCallsByQuery = async (
+  query: Filter<Call>,
+  options?: CallQueryOptions,
+): Promise<CallDoc[]> => {
+  const cursor = getCallsCollection().find(query);
+  return await applyQueryOptions(cursor, options).toArray();
+};
+
+export const countCalls = async (query: Filter<Call>): Promise<number> => {
+  return getCallsCollection().countDocuments(query);
+};
+
+export async function countCallsByPhoneInRange(
+  customerPhoneNumber: string,
+  opts: CountOpts = {},
+  range: DateRange = {},
+): Promise<number> {
+  const filter: Partial<Call> & { customerPhoneNumber: string } = {
+    customerPhoneNumber,
+  };
+
+  if (opts.isOutgoingCall !== undefined) {
+    filter.isOutgoingCall = opts.isOutgoingCall;
+  }
+  if (opts.isIncomingCall !== undefined) {
+    filter.isIncomingCall = opts.isIncomingCall;
+  }
+
+  if (range.since || range.until) {
+    (filter as Filter<Call>).createdAt = {
+      ...(range.since ? { $gte: range.since } : {}),
+      ...(range.until ? { $lt: range.until } : {}),
+    };
+  }
+
+  return getCallsCollection().countDocuments(filter as Filter<Call>);
+}
+
+export const range = {
+  between: (since: Date, until: Date): DateRange => ({ since, until }),
+  todayToNow: (): DateRange => ({ since: startOfDay(), until: new Date() }),
+  yesterday: (): DateRange => {
+    const s = startOfDay(addDays(new Date(), -1));
+    const e = addDays(s, 1);
+    return { since: s, until: e };
+  },
+  todayFull: (): DateRange => {
+    const s = startOfDay();
+    const e = addDays(s, 1);
+    return { since: s, until: e };
+  },
+  startOfDayToNow: (d: Date): DateRange => ({
+    since: startOfDay(d),
+    until: new Date(),
+  }),
+};
+
+export function startOfDay(d: Date = new Date()): Date {
+  const x = new Date(d);
+  x.setUTCHours(0, 0, 0, 0);
+  return x;
+}
+
+export function addDays(d: Date, days: number): Date {
+  const x = new Date(d);
+  x.setDate(x.getDate() + days);
+  return x;
+}
+
+/**
+ * Aggregate calls stats for a date range (createdAt in [startStr, endStr] in timezone).
+ * completed = agentHungUp=true or status='completed'.
+ */
+export async function getCallsStatsForDateRange(
+  clientId: string,
+  startStr: string,
+  endStr: string,
+  timezone: string,
+): Promise<{ count: number; totalLen: number; completed: number }> {
+  const coll = getCallsCollection();
+  const out = await coll
+    .aggregate<{
+      _id: null;
+      count: number;
+      totalLen: number;
+      completed: number;
+    }>([
+      // 1. Restrict to the given client
+      { $match: { clientId } },
+      // 2. Derive dateLocal (createdAt as YYYY-MM-DD in timezone) and isCompleted (agentHungUp or status='completed')
+      {
+        $addFields: {
+          dateLocal: {
+            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
+          },
+          isCompleted: {
+            $or: [
+              { $eq: ["$agentHungUp", true] },
+              { $eq: ["$status", "completed"] },
+            ],
+          },
+        },
+      },
+      // 3. Keep only documents with dateLocal in [startStr, endStr] (inclusive)
+      { $match: { dateLocal: { $gte: startStr, $lte: endStr } } },
+      // 4. Single group: count, totalLen, completed
+      {
+        $group: {
+          _id: null,
+          count: { $sum: 1 },
+          totalLen: { $sum: "$callLength" },
+          completed: { $sum: { $cond: ["$isCompleted", 1, 0] } },
+        },
+      },
+    ])
+    .next();
+  return {
+    count: out?.count ?? 0,
+    totalLen: out?.totalLen ?? 0,
+    completed: out?.completed ?? 0,
+  };
+}
+
+/**
+ * Aggregate calls by hour for a given date (createdAt converted to given timezone). Hour format "HH:mm".
+ */
+export async function getCallsHourlyAggregation(
+  clientId: string,
+  dateStr: string,
+  timezone: string,
+): Promise<DashboardHeatmapMetric[]> {
+  const coll = getCallsCollection();
+  const rows = await coll
+    .aggregate<{ _id: number; calls: number }>([
+      // 1. Restrict to the given client
+      { $match: { clientId } },
+      {
+        $addFields: {
+          dateLocal: {
+            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
+          },
+          hour: { $hour: { date: "$createdAt", timezone } },
+        },
+      },
+      // 3. Keep only the requested date
+      { $match: { dateLocal: dateStr } },
+      // 4. Group by hour, sum calls per hour
+      { $group: { _id: "$hour", calls: { $sum: 1 } } },
+      // 5. Order by hour ascending (0..23)
+      { $sort: { _id: 1 } },
+    ])
+    .toArray();
+
+  return rows.map((r: any) => ({
+    hour: r._id,
+    calls: r.calls,
+  }));
+}