@talkpilot/core-db 1.1.15 → 1.1.16

package/src/municipal/tickets/tickets.types.ts

@@ -1,43 +1,54 @@
-import { ObjectId, WithId } from "mongodb";
-
-import { CityName } from "../utils/types";
-
-export type Ticket = {
-  _id: ObjectId;
-  createdAt: Date;
-  updatedAt: Date;
-  callSid?: string;
-  cityName: CityName;
-  externalCallFields: {
-    // Request fields
-    first_name?: string;
-    last_name?: string;
-    event_description?: string;
-    street?: string;
-    house_number?: string;
-    event_subject_id?: string;
-    event_sub_subject_id?: string;
-    event_sub_subject_id2?: string | null;
-    // Response fields (only if external call was successful)
-    call_number?: string;
-    status?: number; // Response status from Bina API (1 = success)
-    error?: string; // Error message from Bina API if any
-    image1?: string;
-    image2?: string;
-    image3?: string;
-    file1?: string;
-    file2?: string;
-    file3?: string;
-  };
-  guestJwt?: string;
-};
-
-export type TicketDoc = WithId<Ticket>;
-
-/** Call count by department (subject). */
-export type SubjectStatsItem = {
-  subject_name: string;
-  subject_id: string;
-  count: number;
-  percentage: number;
-};
+import { ObjectId, WithId } from "mongodb";
+
+import { CityName } from "../utils/types";
+
+export type Ticket = {
+  _id: ObjectId;
+  createdAt: Date;
+  updatedAt: Date;
+  callSid?: string;
+  isDraft?: boolean;
+  cityName: CityName;
+  externalCallFields: {
+    first_name?: string;
+    last_name?: string;
+    event_description?: string;
+    street?: string;
+    house_number?: string;
+    event_subject_id?: string;
+    event_sub_subject_id?: string;
+    event_sub_subject_id2?: string | null;
+    call_number?: string;
+    status?: number;
+    error?: string;
+    image1?: string;
+    image2?: string;
+    image3?: string;
+    file1?: string;
+    file2?: string;
+    file3?: string;
+  };
+  guestJwt?: string;
+};
+
+export type TicketDoc = WithId<Ticket>;
+
+export type SubjectItem = {
+  subject: string;
+  count: number;
+};
+
+export type TicketSubjectRow = {
+  callSid: string;
+  subject: string;
+};
+
+export type TicketStatsDateScope = {
+  from?: Date;
+  to?: Date;
+};
+
+export type TicketStatsDateRange = {
+  from: Date;
+  to: Date;
+};

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

@@ -0,0 +1,149 @@
+import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import { getDashboardStats } from "../dashboard/calls.dashboard";
+import { getCallsCollection } from "../calls.getters";
+import { getClientsConfigCollection } from "../../clientsConfig/clientsConfig.getters";
+
+describe("getDashboardStats", () => {
+  beforeEach(async () => {
+    await getCallsCollection().deleteMany({});
+    await getClientsConfigCollection().deleteMany({});
+  });
+
+  afterEach(async () => {
+    await getCallsCollection().deleteMany({});
+    await getClientsConfigCollection().deleteMany({});
+  });
+
+  it("should return correct empty dashboard stats when no calls exist", async () => {
+    const clientId = "client-dash-123";
+
+    await getClientsConfigCollection().insertOne({
+      clientId,
+      timezone: "UTC",
+      products: {},
+    } as any);
+
+    const params = {
+      clientId,
+      startDate: "2026-05-01T00:00:00.000Z",
+      endDate: "2026-05-31T23:59:59.999Z",
+    };
+
+    const result = await getDashboardStats(params);
+
+    expect(result).toBeDefined();
+    expect(result.kpis.totalCalls).toBe(0);
+    expect(result.kpis.completedCount).toBe(0);
+    expect(result.kpis.avgDurationSeconds).toBe(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/__tests__/calls.spec.ts

@@ -10,7 +10,7 @@ import {
   getCallsCollection,
   pushToolExecution,
 } from "../calls.getters";
-import type { ToolExecution } from '../calls.types';
+import type { ToolExecution } from "../calls.types";
 import { ObjectId } from "mongodb";
 import { createOutGoingCallDoc } from "../../../test-utils/factories";
 
@@ -115,7 +115,7 @@ describe("db.calls", () => {
     });
   });
 
-  describe('pushToolExecution()', () => {
+  describe("pushToolExecution()", () => {
     let callSid: string;
 
     beforeEach(async () => {
@@ -124,63 +124,73 @@ describe("db.calls", () => {
       callSid = call.callSid;
     });
 
-    const makeHttpExecution = (overrides?: Partial<ToolExecution>): ToolExecution => ({
-      toolName: 'sendSms',
+    const makeHttpExecution = (
+      overrides?: Partial<ToolExecution>,
+    ): ToolExecution => ({
+      toolName: "sendSms",
       executedAt: new Date(),
       durationMs: 120,
-      args: { to: '+1234567890', message: 'hello' },
-      meta: { kind: 'http', url: 'https://api.example.com/sms', method: 'POST' },
-      status: 'success',
+      args: { to: "+1234567890", message: "hello" },
+      meta: {
+        kind: "http",
+        url: "https://api.example.com/sms",
+        method: "POST",
+      },
+      status: "success",
       httpStatus: 200,
       ...overrides,
     });
 
-    it('should append an execution to a call with none', async () => {
+    it("should append an execution to a call with none", async () => {
       const execution = makeHttpExecution();
       await pushToolExecution(callSid, execution);
 
       const result = await getCallByCallSid(callSid);
       expect(result?.toolExecutions).toHaveLength(1);
       expect(result?.toolExecutions?.[0]).toMatchObject({
-        toolName: 'sendSms',
-        status: 'success',
+        toolName: "sendSms",
+        status: "success",
         httpStatus: 200,
       });
     });
 
-    it('should maintain insertion order across multiple pushes', async () => {
-      const first = makeHttpExecution({ toolName: 'first' });
-      const second = makeHttpExecution({ toolName: 'second' });
-      const third = makeHttpExecution({ toolName: 'third' });
+    it("should maintain insertion order across multiple pushes", async () => {
+      const first = makeHttpExecution({ toolName: "first" });
+      const second = makeHttpExecution({ toolName: "second" });
+      const third = makeHttpExecution({ toolName: "third" });
 
       await pushToolExecution(callSid, first);
       await pushToolExecution(callSid, second);
       await pushToolExecution(callSid, third);
 
       const result = await getCallByCallSid(callSid);
-      expect(result?.toolExecutions?.map(e => e.toolName)).toEqual(['first', 'second', 'third']);
+      expect(result?.toolExecutions?.map((e) => e.toolName)).toEqual([
+        "first",
+        "second",
+        "third",
+      ]);
     });
 
-    it('should store an internal tool execution', async () => {
+    it("should store an internal tool execution", async () => {
       const execution: ToolExecution = {
-        toolName: 'endFlow',
+        toolName: "endFlow",
         executedAt: new Date(),
         durationMs: 5,
         args: {},
-        meta: { kind: 'internal' },
-        status: 'success',
+        meta: { kind: "internal" },
+        status: "success",
       };
 
       await pushToolExecution(callSid, execution);
 
       const result = await getCallByCallSid(callSid);
       expect(result?.toolExecutions?.[0]).toMatchObject({
-        toolName: 'endFlow',
-        meta: { kind: 'internal' },
+        toolName: "endFlow",
+        meta: { kind: "internal" },
       });
     });
 
-    it('should store redacted args for sensitive tools', async () => {
+    it("should store redacted args for sensitive tools", async () => {
       const execution = makeHttpExecution({ args: { _redacted: true } });
       await pushToolExecution(callSid, execution);
 
@@ -188,26 +198,34 @@ describe("db.calls", () => {
       expect(result?.toolExecutions?.[0].args).toEqual({ _redacted: true });
     });
 
-    it('should store an error execution', async () => {
-      const execution = makeHttpExecution({ status: 'error', httpStatus: 500 });
+    it("should store an error execution", async () => {
+      const execution = makeHttpExecution({ status: "error", httpStatus: 500 });
       await pushToolExecution(callSid, execution);
 
       const result = await getCallByCallSid(callSid);
-      expect(result?.toolExecutions?.[0]).toMatchObject({ status: 'error', httpStatus: 500 });
+      expect(result?.toolExecutions?.[0]).toMatchObject({
+        status: "error",
+        httpStatus: 500,
+      });
     });
 
-    it('should be a no-op for an unknown callSid', async () => {
-      await expect(pushToolExecution('nonexistent-sid', makeHttpExecution())).resolves.not.toThrow();
+    it("should be a no-op for an unknown callSid", async () => {
+      await expect(
+        pushToolExecution("nonexistent-sid", makeHttpExecution()),
+      ).resolves.not.toThrow();
     });
 
-    it('should store the response body', async () => {
+    it("should store the response body", async () => {
       const execution = makeHttpExecution({
-        response: { userId: '123', status: 'sent' },
+        response: { userId: "123", status: "sent" },
       });
       await pushToolExecution(callSid, execution);
 
       const result = await getCallByCallSid(callSid);
-      expect(result?.toolExecutions?.[0].response).toEqual({ userId: '123', status: 'sent' });
+      expect(result?.toolExecutions?.[0].response).toEqual({
+        userId: "123",
+        status: "sent",
+      });
     });
   });