@talkpilot/core-db 1.1.14 → 1.1.16

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

@@ -1,8 +1,11 @@
 import { ObjectId, Sort, WithId } from "mongodb";
 import { TranscriptionSegment } from "../results";
+import { LeadProperty } from "../leads";
 
-export const CONFERENCE_ROLE_CUSTOMER = "customer" as const;
-export const CONFERENCE_ROLE_SUPERVISOR = "supervisor" as const;
+import {
+  CONFERENCE_ROLE_CUSTOMER,
+  CONFERENCE_ROLE_SUPERVISOR,
+} from "./calls.constants";
 
 export type ConferenceRole =
   | typeof CONFERENCE_ROLE_CUSTOMER
@@ -23,7 +26,7 @@ export type Call = {
   callLength: number;
   transcription?: TranscriptionSegment[];
   status?: string;
-  leads?: Record<string, string>[];
+  leads?: LeadProperty[];
   summary?: string;
   recordingUrl?: string;
   env: string;
@@ -47,21 +50,21 @@ export type ToolExecution = {
   durationMs: number;
   args: Record<string, unknown> | { _redacted: true };
   meta: ToolExecutionMeta;
-  status: 'success' | 'error';
+  status: "success" | "error";
   httpStatus?: number;
   response?: Record<string, unknown>;
 };
 
 export type ToolExecutionMeta =
-    | {
-  kind: 'http';
-  url: string;
-  method: string;
-  flowToolId?: string;
-  runInBackground?: boolean;
-  sensitive?: boolean;
-}
-    | { kind: 'internal' };
+  | {
+      kind: "http";
+      url: string;
+      method: string;
+      flowToolId?: string;
+      runInBackground?: boolean;
+      sensitive?: boolean;
+    }
+  | { kind: "internal" };
 
 export type CallQueryOptions = {
   sort?: Sort;
@@ -102,7 +105,8 @@ export type CallUpdateParams = Partial<Omit<Call, ImmutableCallFields>>;
 
 export type CallDoc = WithId<Call>;
 
-export type CallsByHour = { hour: string; calls: number };
+/** @deprecated use DashboardHeatmapMetric instead */
+export type CallsByHour = { hour: number; calls: number };
 
 export type CountOpts = {
   isOutgoingCall?: boolean;

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

@@ -0,0 +1,292 @@
+import dayjs from "dayjs";
+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,
+  DashboardReportQuery,
+  DashboardReportResponse,
+  DashboardSummaryMetrics,
+  DashboardVolumeGranularity,
+} from "./calls.dashboard.types";
+
+export type {
+  DashboardVolumeGranularity,
+  DashboardReportQuery,
+  DashboardReportResponse,
+} from "./calls.dashboard.types";
+
+const DEFAULT_KPI_DATA = {
+  completedCount: 0,
+  busyCount: 0,
+  answeredDuration: 0,
+};
+
+dayjs.extend(utc);
+dayjs.extend(timezonePlugin);
+dayjs.extend(isoWeek);
+dayjs.extend(quarterOfYear);
+
+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 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",
+            unit: "week",
+            timezone,
+            startOfWeek: "monday",
+          },
+        },
+        timezone,
+      },
+    };
+  }
+
+  if (granularity === "quarter") {
+    return {
+      $concat: [
+        { $toString: { $year: { date: "$createdAt", timezone } } },
+        "-Q",
+        {
+          $toString: {
+            $add: [
+              {
+                $trunc: {
+                  $divide: [
+                    {
+                      $subtract: [
+                        { $month: { date: "$createdAt", timezone } },
+                        1,
+                      ],
+                    },
+                    3,
+                  ],
+                },
+              },
+              1,
+            ],
+          },
+        },
+      ],
+    };
+  }
+
+  return {
+    $dateToString: {
+      format: VOLUME_DATE_FORMATS[granularity],
+      date: "$createdAt",
+      timezone,
+    },
+  };
+}
+
+function buildKpisPipeline() {
+  return [
+    {
+      $group: {
+        _id: null,
+        completedCount: {
+          $sum: { $cond: [{ $eq: ["$status", "completed"] }, 1, 0] },
+        },
+        busyCount: {
+          $sum: { $cond: [{ $eq: ["$status", "busy"] }, 1, 0] },
+        },
+        answeredDuration: {
+          $sum: {
+            $cond: [
+              { $in: ["$status", ["completed", "busy"]] },
+              "$callLength",
+              0,
+            ],
+          },
+        },
+      },
+    },
+  ];
+}
+
+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,
+    granularity: requestedGranularity,
+  } = params;
+  const clientConfig = await getClientConfig(clientId);
+  const timezone = clientConfig?.timezone ?? "UTC";
+
+  const startDateObj = dayjs(startDate).tz(timezone).startOf("day").toDate();
+  const endDateObj = dayjs(endDate).tz(timezone).endOf("day").toDate();
+
+  const granularity =
+    requestedGranularity ?? resolveVolumeGranularity(startDateObj, endDateObj);
+
+  const pipeline = [
+    {
+      $match: {
+        clientId,
+        createdAt: { $gte: startDateObj, $lte: endDateObj },
+      },
+    },
+    {
+      $facet: {
+        kpis: buildKpisPipeline(),
+        volumeData: buildVolumeDataPipeline(timezone, granularity),
+      },
+    },
+  ];
+
+  const callsCollection = getCallsCollection();
+  const [aggregatedResult] = await callsCollection
+    .aggregate<DashboardAggregationResult>(pipeline)
+    .toArray();
+
+  const kpiData = aggregatedResult?.kpis?.[0] ?? DEFAULT_KPI_DATA;
+  const volumeDataRaw = aggregatedResult?.volumeData ?? [];
+
+  const answeredCount = kpiData.completedCount + kpiData.busyCount;
+  const answeredDuration = kpiData.answeredDuration ?? 0;
+
+  const kpis: DashboardSummaryMetrics = {
+    totalCalls: answeredCount,
+    avgDurationSeconds:
+      answeredCount > 0 ? Math.round(answeredDuration / answeredCount) : 0,
+    timeSavedMinutes: Math.round(answeredDuration / 60),
+    completedCount: kpiData.completedCount,
+    busyCount: kpiData.busyCount,
+  };
+
+  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,
+      volumeGranularity: granularity,
+    },
+  };
+  return response;
+}

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

@@ -0,0 +1,57 @@
+export type DashboardHeatmapMetric = {
+  hour: number;
+  calls: number;
+};
+
+export type DashboardDailyTrendMetric = {
+  date: string;
+  completed: number;
+};
+
+export type DashboardVolumeGranularity =
+  | "hour"
+  | "day"
+  | "week"
+  | "month"
+  | "quarter"
+  | "year";
+
+export type DashboardSummaryMetrics = {
+  totalCalls: number;
+  avgDurationSeconds: number;
+  timeSavedMinutes: number;
+  completedCount: number;
+  busyCount: number;
+};
+
+export type DashboardVisualData = {
+  volumeData: DashboardDailyTrendMetric[];
+  volumeGranularity: DashboardVolumeGranularity;
+};
+
+export type DashboardReportQuery = {
+  clientId: string;
+  startDate: string;
+  endDate: string;
+  granularity?: DashboardVolumeGranularity;
+};
+
+export type DashboardReportResponse = {
+  kpis: DashboardSummaryMetrics;
+  charts: DashboardVisualData;
+};
+type RawKpiResult = {
+  completedCount: number;
+  busyCount: number;
+  answeredDuration: number | null;
+};
+
+export type RawVolumeAggregationResult = {
+  _id: string;
+  completed: number;
+};
+
+export interface DashboardAggregationResult {
+  kpis: RawKpiResult[];
+  volumeData: RawVolumeAggregationResult[];
+}

package/src/talkpilot/calls/index.ts

@@ -1,2 +1,6 @@
+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.getters.spec.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import {
+  getClientsConfigCollection,
+  updateProductConfig,
+} from "../clientsConfig.getters";
+
+describe("updateProductConfig", () => {
+  beforeEach(async () => {
+    await getClientsConfigCollection().deleteMany({});
+  });
+
+  afterEach(async () => {
+    await getClientsConfigCollection().deleteMany({});
+  });
+
+  it("should update partial fields using correct dot notation", async () => {
+    const clientId = "client-123";
+    const collection = getClientsConfigCollection();
+
+    await collection.insertOne({
+      clientId,
+      products: {
+        websiteTalk: {
+          language: "English",
+          companyName: "OldCorp",
+          defaultBaseUrl: "https://old-url.com",
+          logoUrl: "",
+          timezone: "UTC",
+        },
+      },
+    } as any);
+
+    const updates = { language: "Hebrew", companyName: "TestCorp" };
+    await updateProductConfig(clientId, "websiteTalk", updates);
+
+    const updatedDoc = await collection.findOne({ clientId });
+
+    expect(updatedDoc).toBeDefined();
+    expect(updatedDoc?.products.websiteTalk?.language).toBe("Hebrew");
+    expect(updatedDoc?.products.websiteTalk?.companyName).toBe("TestCorp");
+    expect(updatedDoc?.products.websiteTalk?.defaultBaseUrl).toBe(
+      "https://old-url.com",
+    );
+  });
+
+  it("should throw an error if no client config is found", async () => {
+    await expect(
+      updateProductConfig("invalid-client", "websiteTalk", {
+        language: "English",
+      }),
+    ).rejects.toThrow("No client config found for clientId: invalid-client");
+  });
+});

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",
-            },
           },
         },
       });
@@ -70,6 +63,97 @@ describe("db.clientsConfig", () => {
       expect(result).toBeNull();
     });
 
+    it("given moked_106 with both toolsPrompts when saved and retrieved then both prompts are persisted", async () => {
+      // Given
+      const clientId = "tools-prompts-both";
+      const clientConfig = createClientConfig({
+        clientId,
+        products: {
+          municipal: {
+            cityName: "ashdod",
+            timezone: "Asia/Jerusalem",
+            moked_106: {
+              toolsPrompts: {
+                findSubjectsSystemPrompt: "Custom subjects prompt",
+                findStreetsSystemPrompt: "Custom streets prompt",
+              },
+            },
+          },
+        },
+      });
+
+      // When
+      await createClientConfigDoc(clientConfig);
+      const result = await getClientConfig(clientId);
+
+      // Then
+      expect(result?.products.municipal?.moked_106?.toolsPrompts).toMatchObject(
+        {
+          findSubjectsSystemPrompt: "Custom subjects prompt",
+          findStreetsSystemPrompt: "Custom streets prompt",
+        },
+      );
+    });
+
+    it("given moked_106 with findSubjectsSystemPrompt only when saved and retrieved then findStreetsSystemPrompt is undefined", async () => {
+      // Given
+      const clientId = "tools-prompts-subjects-only";
+      const clientConfig = createClientConfig({
+        clientId,
+        products: {
+          municipal: {
+            cityName: "ashdod",
+            timezone: "Asia/Jerusalem",
+            moked_106: {
+              toolsPrompts: {
+                findSubjectsSystemPrompt: "Subjects only prompt",
+              },
+            },
+          },
+        },
+      });
+
+      // When
+      await createClientConfigDoc(clientConfig);
+      const result = await getClientConfig(clientId);
+
+      // Then
+      expect(
+        result?.products.municipal?.moked_106?.toolsPrompts
+          ?.findSubjectsSystemPrompt,
+      ).toBe("Subjects only prompt");
+      expect(
+        result?.products.municipal?.moked_106?.toolsPrompts
+          ?.findStreetsSystemPrompt,
+      ).toBeUndefined();
+    });
+
+    it("given moked_106 without toolsPrompts when saved and retrieved then toolsPrompts is undefined", async () => {
+      // Given
+      const clientId = "tools-prompts-absent";
+      const clientConfig = createClientConfig({
+        clientId,
+        products: {
+          municipal: {
+            cityName: "ashdod",
+            timezone: "Asia/Jerusalem",
+            moked_106: {
+              avoidSaveTickets: true,
+            },
+          },
+        },
+      });
+
+      // When
+      await createClientConfigDoc(clientConfig);
+      const result = await getClientConfig(clientId);
+
+      // Then
+      expect(
+        result?.products.municipal?.moked_106?.toolsPrompts,
+      ).toBeUndefined();
+    });
+
     it("should support communications config", async () => {
       const clientId = "communications-test";
       const clientConfig = createClientConfig({

package/src/talkpilot/clientsConfig/clientsConfig.getters.ts

@@ -1,4 +1,11 @@
-import { ClientConfigDoc, getDb, findClientByPhoneNumber } from "../index";
+import {
+  ClientConfigDoc,
+  getDb,
+  findClientByPhoneNumber,
+  Products,
+  KNOWN_PRODUCT_KEYS,
+  KnownProductKey,
+} from "../index";
 import { Collection } from "mongodb";
 
 export const getClientsConfigCollection = (): Collection<ClientConfigDoc> => {
@@ -20,3 +27,29 @@ export const createClientConfigDoc = async (
 ): Promise<void> => {
   await getClientsConfigCollection().insertOne(clientConfig);
 };
+
+export async function updateProductConfig<K extends KnownProductKey>(
+  clientId: string,
+  productKey: K,
+  updates: Partial<Products[K]>,
+): Promise<void> {
+  if (!KNOWN_PRODUCT_KEYS.includes(productKey as KnownProductKey)) {
+    throw new Error(
+      `Invalid product key: "${productKey}". Must be one of: ${KNOWN_PRODUCT_KEYS.join(", ")}`,
+    );
+  }
+
+  const setOperations: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(updates)) {
+    setOperations[`products.${productKey}.${key}`] = value;
+  }
+
+  const result = await getClientsConfigCollection().updateOne(
+    { clientId },
+    { $set: setOperations },
+  );
+
+  if (result.matchedCount === 0) {
+    throw new Error(`No client config found for clientId: ${clientId}`);
+  }
+}