@talkpilot/core-db 1.3.0 → 1.3.3

package/src/talkpilot/calls/__tests__/calls.dashboard.spec.ts

@@ -25,8 +25,8 @@ describe("getDashboardStats", () => {
 
     const params = {
       clientId,
-      startDate: "2026-05-01",
-      endDate: "2026-05-31",
+      startDate: "2026-05-01T00:00:00.000Z",
+      endDate: "2026-05-31T23:59:59.999Z",
     };
 
     const result = await getDashboardStats(params);
@@ -35,12 +35,115 @@ describe("getDashboardStats", () => {
     expect(result.kpis.totalCalls).toBe(0);
     expect(result.kpis.completedCount).toBe(0);
     expect(result.kpis.avgDurationSeconds).toBe(0);
-    expect(result.charts.volumeData).toEqual([]);
-    expect(result.charts.heatmap).toEqual({});
-    expect(result.charts.callLengthBuckets).toEqual({
-      short: 0,
-      medium: 0,
-      long: 0,
+    expect(result.kpis.busyCount).toBe(0);
+    expect(result.kpis.timeSavedMinutes).toBe(0);
+    // ~30 day range -> daily buckets, gap-filled with zeros across the whole range
+    expect(result.charts.volumeGranularity).toBe("day");
+    expect(result.charts.volumeData.length).toBeGreaterThan(0);
+    expect(result.charts.volumeData.every((d) => d.completed === 0)).toBe(true);
+    expect(result.charts.volumeData[0].date).toBe("2026-05-01");
+    expect(
+      result.charts.volumeData[result.charts.volumeData.length - 1].date,
+    ).toBe("2026-05-31");
+  });
+
+  it("should pick a bucket size that keeps the volume chart readable across range lengths", async () => {
+    const clientId = "client-dash-456";
+
+    await getClientsConfigCollection().insertOne({
+      clientId,
+      timezone: "UTC",
+      products: {},
+    } as any);
+
+    const oneDay = await getDashboardStats({
+      clientId,
+      startDate: "2026-05-01T00:00:00.000Z",
+      endDate: "2026-05-01T23:59:59.999Z",
+    });
+    expect(oneDay.charts.volumeGranularity).toBe("hour");
+
+    const threeWeeks = await getDashboardStats({
+      clientId,
+      startDate: "2026-05-01T00:00:00.000Z",
+      endDate: "2026-05-21T23:59:59.999Z",
+    });
+    expect(threeWeeks.charts.volumeGranularity).toBe("day");
+
+    const fourMonths = await getDashboardStats({
+      clientId,
+      startDate: "2026-01-01T00:00:00.000Z",
+      endDate: "2026-04-30T23:59:59.999Z",
+    });
+    expect(fourMonths.charts.volumeGranularity).toBe("week");
+
+    const eighteenMonths = await getDashboardStats({
+      clientId,
+      startDate: "2025-01-01T00:00:00.000Z",
+      endDate: "2026-06-30T23:59:59.999Z",
+    });
+    expect(eighteenMonths.charts.volumeGranularity).toBe("month");
+
+    const threeYears = await getDashboardStats({
+      clientId,
+      startDate: "2023-01-01T00:00:00.000Z",
+      endDate: "2026-01-01T23:59:59.999Z",
+    });
+    expect(threeYears.charts.volumeGranularity).toBe("quarter");
+
+    const fiveYears = await getDashboardStats({
+      clientId,
+      startDate: "2021-01-01T00:00:00.000Z",
+      endDate: "2026-01-01T23:59:59.999Z",
+    });
+    expect(fiveYears.charts.volumeGranularity).toBe("year");
+  });
+
+  it("should fill gaps with zero-count buckets so the chart has no missing points", async () => {
+    const clientId = "client-dash-789";
+
+    await getClientsConfigCollection().insertOne({
+      clientId,
+      timezone: "UTC",
+      products: {},
+    } as any);
+
+    // Sparse data: only two of the day's hours have calls.
+    await getCallsCollection().insertMany([
+      {
+        clientId,
+        status: "completed",
+        callLength: 60,
+        createdAt: new Date("2026-05-01T09:15:00Z"),
+      },
+      {
+        clientId,
+        status: "completed",
+        callLength: 90,
+        createdAt: new Date("2026-05-01T18:45:00Z"),
+      },
+    ] as any);
+
+    const result = await getDashboardStats({
+      clientId,
+      startDate: "2026-05-01T00:00:00.000Z",
+      endDate: "2026-05-01T23:59:59.999Z",
     });
+
+    expect(result.charts.volumeGranularity).toBe("hour");
+    // A full day of hourly buckets, with no gaps, sorted chronologically.
+    expect(result.charts.volumeData).toHaveLength(24);
+    expect(result.charts.volumeData[0].date).toBe("2026-05-01T00:00");
+    expect(result.charts.volumeData[23].date).toBe("2026-05-01T23:00");
+
+    const populated = result.charts.volumeData.filter((d) => d.completed > 0);
+    expect(populated).toHaveLength(2);
+    expect(populated.map((d) => d.date)).toEqual([
+      "2026-05-01T09:00",
+      "2026-05-01T18:00",
+    ]);
+
+    const empty = result.charts.volumeData.filter((d) => d.completed === 0);
+    expect(empty).toHaveLength(22);
   });
 });

package/src/talkpilot/calls/calls.types.ts

@@ -2,10 +2,8 @@ import { ObjectId, Sort, WithId } from "mongodb";
 import { TranscriptionSegment } from "../results";
 import { LeadProperty } from "../leads";
 
-import {
-  CONFERENCE_ROLE_CUSTOMER,
-  CONFERENCE_ROLE_SUPERVISOR,
-} from "./calls.constants";
+export const CONFERENCE_ROLE_CUSTOMER = "customer" as const;
+export const CONFERENCE_ROLE_SUPERVISOR = "supervisor" as const;
 
 export type ConferenceRole =
   | typeof CONFERENCE_ROLE_CUSTOMER

package/src/talkpilot/calls/dashboard/calls.dashboard.ts

@@ -3,173 +3,237 @@ import { getCallsCollection } from "../calls.getters";
 import { getClientConfig } from "../../clientsConfig";
 import utc from "dayjs/plugin/utc";
 import timezonePlugin from "dayjs/plugin/timezone";
+import isoWeek from "dayjs/plugin/isoWeek";
+import quarterOfYear from "dayjs/plugin/quarterOfYear";
 import {
   DashboardAggregationResult,
   DashboardDailyTrendMetric,
-  DashboardHeatmapMetric,
   DashboardReportQuery,
   DashboardReportResponse,
   DashboardSummaryMetrics,
-  RawDailyAggregationResult,
-  RawHourlyAggregationResult,
+  DashboardVolumeGranularity,
+} from "./calls.dashboard.types";
+
+export type {
+  DashboardVolumeGranularity,
+  DashboardReportQuery,
+  DashboardReportResponse,
 } from "./calls.dashboard.types";
-import { CallLengthThresholds } from "src/utils/shared.types";
 
 const DEFAULT_KPI_DATA = {
-  totalCalls: 0,
-  totalDuration: 0,
   completedCount: 0,
-  failedCount: 0,
-  noAnswerCount: 0,
   busyCount: 0,
+  answeredDuration: 0,
 };
 
 dayjs.extend(utc);
 dayjs.extend(timezonePlugin);
+dayjs.extend(isoWeek);
+dayjs.extend(quarterOfYear);
 
-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] },
-        },
-      },
-    },
-  ];
+const BUCKET_UNIT: Record<DashboardVolumeGranularity, string> = {
+  hour: "hour",
+  day: "day",
+  week: "isoWeek",
+  month: "month",
+  quarter: "quarter",
+  year: "year",
+};
+
+function formatBucketKey(
+  bucketStart: dayjs.Dayjs,
+  granularity: DashboardVolumeGranularity,
+): string {
+  switch (granularity) {
+    case "hour":
+      return bucketStart.format("YYYY-MM-DDTHH:00");
+    case "day":
+    case "week":
+      return bucketStart.format("YYYY-MM-DD");
+    case "month":
+      return bucketStart.format("YYYY-MM");
+    case "quarter":
+      return `${bucketStart.format("YYYY")}-Q${bucketStart.quarter()}`;
+    case "year":
+      return bucketStart.format("YYYY");
+  }
 }
 
-function buildDailyDataPipeline(timezone: string) {
-  return [
-    {
-      $group: {
-        _id: {
-          $dateToString: {
-            format: "%Y-%m-%d",
+function generateBucketKeys(
+  startDateObj: Date,
+  endDateObj: Date,
+  granularity: DashboardVolumeGranularity,
+  timezone: string,
+): string[] {
+  const unitName = BUCKET_UNIT[granularity];
+  const startOfUnit = unitName as dayjs.OpUnitType;
+  const stepUnit = (
+    unitName === "isoWeek" ? "week" : unitName
+  ) as dayjs.ManipulateType;
+  const end = dayjs(endDateObj).tz(timezone);
+  let cursor = dayjs(startDateObj).tz(timezone).startOf(startOfUnit);
+
+  const keys: string[] = [];
+  while (cursor.isBefore(end) || cursor.isSame(end, startOfUnit)) {
+    keys.push(formatBucketKey(cursor, granularity));
+    cursor = cursor.add(1, stepUnit);
+  }
+  return keys;
+}
+
+function fillVolumeGaps(
+  bucketKeys: string[],
+  volumeDataRaw: { date: string; completed: number }[],
+): DashboardDailyTrendMetric[] {
+  const completedByKey = new Map(
+    volumeDataRaw.map((d) => [d.date, d.completed]),
+  );
+  return bucketKeys.map((date) => ({
+    date,
+    completed: completedByKey.get(date) ?? 0,
+  }));
+}
+
+function resolveVolumeGranularity(
+  startDateObj: Date,
+  endDateObj: Date,
+): DashboardVolumeGranularity {
+  const spanDays = dayjs(endDateObj).diff(dayjs(startDateObj), "day");
+
+  if (spanDays <= 2) return "hour";
+  if (spanDays <= 60) return "day";
+  if (spanDays <= 365) return "week";
+  if (spanDays <= 730) return "month";
+  if (spanDays <= 1460) return "quarter";
+  return "year";
+}
+
+const VOLUME_DATE_FORMATS: Partial<Record<DashboardVolumeGranularity, string>> =
+  {
+    hour: "%Y-%m-%dT%H:00",
+    day: "%Y-%m-%d",
+    month: "%Y-%m",
+    year: "%Y",
+  };
+
+function buildVolumeBucketIdExpression(
+  timezone: string,
+  granularity: DashboardVolumeGranularity,
+) {
+  if (granularity === "week") {
+    return {
+      $dateToString: {
+        format: "%Y-%m-%d",
+        date: {
+          $dateTrunc: {
             date: "$createdAt",
-            timezone: timezone,
+            unit: "week",
+            timezone,
+            startOfWeek: "monday",
           },
         },
-        count: { $sum: 1 },
-        completed: {
-          $sum: { $cond: [{ $eq: ["$status", "completed"] }, 1, 0] },
-        },
+        timezone,
       },
-    },
-    { $sort: { _id: 1 } },
-  ];
-}
+    };
+  }
 
-function buildHourlyDataPipeline(timezone: string) {
-  return [
-    {
-      $group: {
-        _id: {
-          day: {
-            $dateToString: {
-              format: "%Y-%m-%d",
-              date: "$createdAt",
-              timezone: timezone,
-            },
+  if (granularity === "quarter") {
+    return {
+      $concat: [
+        { $toString: { $year: { date: "$createdAt", timezone } } },
+        "-Q",
+        {
+          $toString: {
+            $add: [
+              {
+                $trunc: {
+                  $divide: [
+                    {
+                      $subtract: [
+                        { $month: { date: "$createdAt", timezone } },
+                        1,
+                      ],
+                    },
+                    3,
+                  ],
+                },
+              },
+              1,
+            ],
           },
-          hour: { $hour: { date: "$createdAt", timezone: timezone } },
         },
-        count: { $sum: 1 },
-      },
+      ],
+    };
+  }
+
+  return {
+    $dateToString: {
+      format: VOLUME_DATE_FORMATS[granularity],
+      date: "$createdAt",
+      timezone,
     },
-  ];
+  };
 }
 
-export function buildCallLengthBucketsPipeline(
-  thresholds: CallLengthThresholds,
-) {
-  const { shortThreshold, mediumThreshold } = thresholds;
-
+function buildKpisPipeline() {
   return [
     {
       $group: {
         _id: null,
-        short: {
-          $sum: { $cond: [{ $lt: ["$callLength", shortThreshold] }, 1, 0] },
+        completedCount: {
+          $sum: { $cond: [{ $eq: ["$status", "completed"] }, 1, 0] },
         },
-        medium: {
+        busyCount: {
+          $sum: { $cond: [{ $eq: ["$status", "busy"] }, 1, 0] },
+        },
+        answeredDuration: {
           $sum: {
             $cond: [
-              {
-                $and: [
-                  { $gte: ["$callLength", shortThreshold] },
-                  { $lte: ["$callLength", mediumThreshold] },
-                ],
-              },
-              1,
+              { $in: ["$status", ["completed", "busy"]] },
+              "$callLength",
               0,
             ],
           },
         },
-        long: {
-          $sum: { $cond: [{ $gt: ["$callLength", mediumThreshold] }, 1, 0] },
-        },
       },
     },
   ];
 }
 
-function buildHeatmapData(
-  hourlyDataRaw: RawHourlyAggregationResult[],
-): Record<string, DashboardHeatmapMetric[]> {
-  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>,
-  ): DashboardHeatmapMetric[] =>
-    Array.from(map.entries())
-      .sort(([a], [b]) => a - b)
-      .map(([h, c]) => ({
-        hour: h,
-        calls: c,
-      }));
-
-  const heatmap: Record<string, DashboardHeatmapMetric[]> = {};
-  for (const [day, hourMap] of Array.from(heatmapMap.entries()).sort()) {
-    heatmap[day] = toSortedBuckets(hourMap);
-  }
-
-  return heatmap;
+function buildVolumeDataPipeline(
+  timezone: string,
+  granularity: DashboardVolumeGranularity,
+) {
+  return [
+    {
+      $group: {
+        _id: buildVolumeBucketIdExpression(timezone, granularity),
+        completed: {
+          $sum: { $cond: [{ $eq: ["$status", "completed"] }, 1, 0] },
+        },
+      },
+    },
+    { $sort: { _id: 1 } },
+  ];
 }
 
 export async function getDashboardStats(
   params: DashboardReportQuery,
 ): Promise<DashboardReportResponse> {
-  const { clientId, startDate, endDate } = params;
+  const {
+    clientId,
+    startDate,
+    endDate,
+    granularity: requestedGranularity,
+  } = params;
   const clientConfig = await getClientConfig(clientId);
   const timezone = clientConfig?.timezone ?? "UTC";
 
-  const startDateObj = dayjs.tz(startDate, timezone).startOf("day").toDate();
-  const endDateObj = dayjs.tz(endDate, timezone).endOf("day").toDate();
+  const startDateObj = dayjs(startDate).tz(timezone).startOf("day").toDate();
+  const endDateObj = dayjs(endDate).tz(timezone).endOf("day").toDate();
 
-  const thresholds: CallLengthThresholds = {
-    shortThreshold: clientConfig?.callLengthThresholds?.shortThreshold ?? 60,
-    mediumThreshold: clientConfig?.callLengthThresholds?.mediumThreshold ?? 180,
-  };
+  const granularity =
+    requestedGranularity ?? resolveVolumeGranularity(startDateObj, endDateObj);
 
   const pipeline = [
     {
@@ -181,9 +245,7 @@ export async function getDashboardStats(
     {
       $facet: {
         kpis: buildKpisPipeline(),
-        dailyData: buildDailyDataPipeline(timezone),
-        hourlyData: buildHourlyDataPipeline(timezone),
-        callLengthBuckets: buildCallLengthBucketsPipeline(thresholds),
+        volumeData: buildVolumeDataPipeline(timezone, granularity),
       },
     },
   ];
@@ -194,49 +256,36 @@ export async function getDashboardStats(
     .toArray();
 
   const kpiData = aggregatedResult?.kpis?.[0] ?? DEFAULT_KPI_DATA;
-  const dailyDataRaw = aggregatedResult?.dailyData ?? [];
-  const hourlyDataRaw = aggregatedResult?.hourlyData ?? [];
-  const callLengthRaw = aggregatedResult?.callLengthBuckets?.[0] ?? {
-    short: 0,
-    medium: 0,
-    long: 0,
-  };
+  const volumeDataRaw = aggregatedResult?.volumeData ?? [];
+
+  const answeredCount = kpiData.completedCount + kpiData.busyCount;
+  const answeredDuration = kpiData.answeredDuration ?? 0;
 
   const kpis: DashboardSummaryMetrics = {
-    totalCalls: kpiData.totalCalls,
+    totalCalls: answeredCount,
     avgDurationSeconds:
-      kpiData.totalCalls > 0
-        ? Math.round((kpiData.totalDuration ?? 0) / kpiData.totalCalls)
-        : 0,
-    timeSavedMinutes: Math.round((kpiData.totalDuration ?? 0) / 60),
-    successRate:
-      kpiData.totalCalls > 0
-        ? Math.round((kpiData.completedCount / kpiData.totalCalls) * 1000) / 10
-        : 0,
+      answeredCount > 0 ? Math.round(answeredDuration / answeredCount) : 0,
+    timeSavedMinutes: Math.round(answeredDuration / 60),
     completedCount: kpiData.completedCount,
-    failedCount: kpiData.failedCount,
-    noAnswerCount: kpiData.noAnswerCount,
     busyCount: kpiData.busyCount,
   };
 
-  const volumeData: DashboardDailyTrendMetric[] = dailyDataRaw.map((d) => ({
-    date: d._id,
-    count: d.count,
-    completed: d.completed,
-  }));
-
-  const heatmap = buildHeatmapData(hourlyDataRaw);
+  const bucketKeys = generateBucketKeys(
+    startDateObj,
+    endDateObj,
+    granularity,
+    timezone,
+  );
+  const volumeData: DashboardDailyTrendMetric[] = fillVolumeGaps(
+    bucketKeys,
+    volumeDataRaw.map((d) => ({ date: d._id, completed: d.completed })),
+  );
 
   const response: DashboardReportResponse = {
     kpis,
     charts: {
       volumeData,
-      heatmap,
-      callLengthBuckets: {
-        short: callLengthRaw.short,
-        medium: callLengthRaw.medium,
-        long: callLengthRaw.long,
-      },
+      volumeGranularity: granularity,
     },
   };
   return response;

package/src/talkpilot/calls/dashboard/calls.dashboard.types.ts

@@ -5,37 +5,35 @@ export type DashboardHeatmapMetric = {
 
 export type DashboardDailyTrendMetric = {
   date: string;
-  count: number;
   completed: number;
 };
 
-export type DashboardDurationSegments = {
-  short: number;
-  medium: number;
-  long: number;
-};
+export type DashboardVolumeGranularity =
+  | "hour"
+  | "day"
+  | "week"
+  | "month"
+  | "quarter"
+  | "year";
 
 export type DashboardSummaryMetrics = {
   totalCalls: number;
   avgDurationSeconds: number;
   timeSavedMinutes: number;
-  successRate: number;
   completedCount: number;
-  failedCount: number;
-  noAnswerCount: number;
   busyCount: number;
 };
 
 export type DashboardVisualData = {
   volumeData: DashboardDailyTrendMetric[];
-  heatmap: Record<string, DashboardHeatmapMetric[]>;
-  callLengthBuckets: DashboardDurationSegments;
+  volumeGranularity: DashboardVolumeGranularity;
 };
 
 export type DashboardReportQuery = {
   clientId: string;
   startDate: string;
   endDate: string;
+  granularity?: DashboardVolumeGranularity;
 };
 
 export type DashboardReportResponse = {
@@ -43,28 +41,17 @@ export type DashboardReportResponse = {
   charts: DashboardVisualData;
 };
 type RawKpiResult = {
-  totalCalls: number;
-  totalDuration: number | null;
   completedCount: number;
-  failedCount: number;
-  noAnswerCount: number;
   busyCount: number;
+  answeredDuration: number | null;
 };
 
-export type RawDailyAggregationResult = {
+export type RawVolumeAggregationResult = {
   _id: string;
-  count: number;
   completed: number;
 };
 
-export type RawHourlyAggregationResult = {
-  _id: { day: string; hour: number };
-  count: number;
-};
-
 export interface DashboardAggregationResult {
   kpis: RawKpiResult[];
-  dailyData: RawDailyAggregationResult[];
-  hourlyData: RawHourlyAggregationResult[];
-  callLengthBuckets: DashboardDurationSegments[];
+  volumeData: RawVolumeAggregationResult[];
 }

package/src/talkpilot/calls/index.ts

@@ -1,6 +1,3 @@
-export * from "./calls.constants";
 export * from "./calls.types";
 export * from "./calls.getters";
-export * from "./calls.statistics.types";
-export * from "./calls.statistics.getters";
 export * from "./dashboard/calls.dashboard";

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

@@ -36,10 +36,6 @@ describe("db.clientsConfig", () => {
             timezone: "Asia/Jerusalem",
             language: "he",
             defaultBaseUrl: "https://acme.example",
-            scheduler: {
-              type: "cron",
-              schedule: "0 9 * * 1-5",
-            },
           },
         },
       });
@@ -57,9 +53,6 @@ describe("db.clientsConfig", () => {
             timezone: "Asia/Jerusalem",
             language: "he",
             defaultBaseUrl: "https://acme.example",
-            scheduler: {
-              type: "cron",
-            },
           },
         },
       });