@talkpilot/core-db 1.3.4 → 1.3.5

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/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",
-            },
           },
         },
       });

package/src/test-utils/db-utils.ts

@@ -1,6 +1,6 @@
 import { MongoMemoryServer } from "mongodb-memory-server";
 import { MongoClient, Db } from "mongodb";
-import { setDb, setMunicipalDataDb } from "../index";
+import { setDb, setMunicipalDataDb, setWebsitalkDb } from "../index";
 
 let mongoServer: MongoMemoryServer;
 let client: MongoClient;
@@ -13,8 +13,10 @@ export async function initTestDb(): Promise<Db> {
   await client.connect();
   const talkpilotDb = client.db();
   const municipalDb = client.db("municipal-data");
+  const websitalkDb = client.db("website-talk");
   setDb(talkpilotDb);
   setMunicipalDataDb(municipalDb);
+  setWebsitalkDb(websitalkDb);
   return talkpilotDb;
 }
 

package/src/test-utils/factories/index.ts

@@ -8,5 +8,7 @@ export * from "./talkpilot/phone_numbers";
 export * from "./talkpilot/sessions";
 export * from "./municipal/cities";
 export * from "./municipal/departmentsSubjects";
+export * from "./municipal/muniIssues";
 export * from "./municipal/streets";
 export * from "./municipal/tickets";
+export * from "./websitalk/scans";

package/src/test-utils/factories/municipal/muniIssues.ts

@@ -0,0 +1,32 @@
+import { Factory } from "fishery";
+import { faker } from "@faker-js/faker";
+import type { CreateMuniIssueInput } from "../../../municipal";
+
+/**
+ * Test factory for `createMuniIssue` input.
+ * `jira.key` uses `sequence` so each build gets a unique key (the real key
+ * comes from Jira in production).
+ */
+export const muniIssueInputFactory = Factory.define<CreateMuniIssueInput>(
+  ({ sequence }) => ({
+    callSid: `CA${faker.string.alphanumeric(10)}`,
+    clientId: faker.string.uuid(),
+    cityName: faker.location.city(),
+    issueContent: {
+      issuerName: faker.person.fullName(),
+      issuerRole: faker.person.jobTitle(),
+      issueDescription: faker.lorem.sentence(),
+      desiredBehavior: faker.lorem.sentence(),
+    },
+    jira: {
+      key: `CP-${sequence}`,
+      syncStatus: "created",
+    },
+  }),
+);
+
+export function createMuniIssueInput(
+  overrides?: Partial<CreateMuniIssueInput>,
+): CreateMuniIssueInput {
+  return muniIssueInputFactory.build(overrides);
+}

package/src/test-utils/factories/websitalk/scans.ts

@@ -0,0 +1,23 @@
+import { Factory } from "fishery";
+import { faker } from "@faker-js/faker";
+import type { Scan } from "../../../websitalk";
+
+export const scanFactory = Factory.define<Scan>(() => ({
+  clientId: faker.string.uuid(),
+  baseUrl: faker.internet.url(),
+  status: "CHECKING",
+  activeTasksCount: 0,
+  pagesScanned: 0,
+  pagesSkipped: 0,
+  skipped: [],
+  siteChrome: {
+    url: faker.internet.url(),
+    sourceType: "site_chrome",
+  },
+  createdAt: new Date(),
+  updatedAt: new Date(),
+}));
+
+export function createScanFixture(overrides?: Partial<Scan>): Scan {
+  return scanFactory.build(overrides);
+}

package/src/websitalk/index.ts

@@ -0,0 +1,15 @@
+import { Db, ObjectId as MongoObjectId } from "mongodb";
+
+export * from "./scans";
+export { websitalkMongodbClient } from "./mongodb-client";
+
+let db: Db;
+export const setDb = (d: Db) => {
+  db = d;
+};
+
+export const getDb = (): Db => {
+  if (!db) throw new Error("Website Talk DB not initialised");
+  return db;
+};
+export const ObjectId = MongoObjectId;