@talkpilot/core-db 1.1.3 → 1.1.5

package/src/talkpilot/agents/__tests__/agents.getters.spec.ts

@@ -1,14 +1,14 @@
-import { findAgents } from '../agents.getters';
-import { setDb } from '../../index';
-import { Db, Collection } from 'mongodb';
-import { createAgent } from '../../../test-utils/factories';
+import { findAgents } from "../agents.getters";
+import { setDb } from "../../index";
+import { Db, Collection } from "mongodb";
+import { createAgent } from "../../../test-utils/factories";
 
-describe('agents getters', () => {
+describe("agents getters", () => {
   let mockDb: Partial<Db>;
   let mockCollection: Partial<Collection>;
 
   beforeEach(() => {
-    const mockAgent = createAgent({ name: 'Agent Smith' });
+    const mockAgent = createAgent({ name: "Agent Smith" });
     mockCollection = {
       find: jest.fn().mockReturnValue({
         toArray: jest.fn().mockResolvedValue([mockAgent]),
@@ -20,10 +20,10 @@ describe('agents getters', () => {
     setDb(mockDb as Db);
   });
 
-  it('findAgents should return agents', async () => {
+  it("findAgents should return agents", async () => {
     const result = await findAgents();
-    
-    expect(mockDb.collection).toHaveBeenCalledWith('agents');
-    expect(result[0].name).toBe('Agent Smith');
+
+    expect(mockDb.collection).toHaveBeenCalledWith("agents");
+    expect(result[0].name).toBe("Agent Smith");
   });
 });

package/src/talkpilot/agents/agents.getters.ts

@@ -1,7 +1,7 @@
-import { getDb, Agent, ObjectId } from '../index';
+import { getDb, Agent, ObjectId } from "../index";
 
 export const getAgentsCollection = () => {
-  return getDb().collection<Agent>('agents');
+  return getDb().collection<Agent>("agents");
 };
 
 export const findAgents = async (filter: any = {}) => {
@@ -25,7 +25,7 @@ export const updateAgent = (agentId: string, data: Partial<Agent>) => {
   return getAgentsCollection().findOneAndUpdate(
     { _id: new ObjectId(agentId) },
     { $set: data },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
 };
 

package/src/talkpilot/agents/agents.types.ts

@@ -1,4 +1,4 @@
-import { WithId } from 'mongodb';
+import { WithId } from "mongodb";
 
 export type Agent = {
   name: string;
@@ -8,7 +8,7 @@ export type Agent = {
   labels: string[];
   clientId: string;
   role: string;
-  gender: 'male' | 'female';
+  gender: "male" | "female";
 };
 
 export type AgentDoc = WithId<Agent>;

package/src/talkpilot/agents/index.ts

@@ -1,2 +1,2 @@
-export * from './agents.getters';
-export * from './agents.types';
+export * from "./agents.getters";
+export * from "./agents.types";

package/src/talkpilot/backgroundToolResults/__tests__/backgroundToolResults.getters.spec.ts

@@ -3,23 +3,28 @@ import {
   upsertBackgroundToolResult,
   findBackgroundToolResult,
   findBackgroundToolResultsByCallSid,
-} from '../backgroundToolResults.getters';
-import { BackgroundToolStatus } from '../backgroundToolResults.types';
+} from "../backgroundToolResults.getters";
+import { BackgroundToolStatus } from "../backgroundToolResults.types";
 
-describe('backgroundToolResults getters', () => {
+describe("backgroundToolResults getters", () => {
   it('should return the "backgroundToolResults" collection', () => {
     const collection = getBackgroundToolResultsCollection();
-    expect(collection.collectionName).toBe('backgroundToolResults');
+    expect(collection.collectionName).toBe("backgroundToolResults");
   });
 
-  it('should create a new background tool result with correct fields and default TTL', async () => {
-    const callSid = 'CA-background-call-1';
-    const toolName = 'exampleTool';
-    const status: BackgroundToolStatus = 'pending';
+  it("should create a new background tool result with correct fields and default TTL", async () => {
+    const callSid = "CA-background-call-1";
+    const toolName = "exampleTool";
+    const status: BackgroundToolStatus = "pending";
     const result = null;
 
     const before = new Date();
-    const doc = await upsertBackgroundToolResult({ callSid, toolName, status, result });
+    const doc = await upsertBackgroundToolResult({
+      callSid,
+      toolName,
+      status,
+      result,
+    });
     const after = new Date();
 
     expect(doc).not.toBeNull();
@@ -42,14 +47,14 @@ describe('backgroundToolResults getters', () => {
     expect(doc!.updatedAt.getTime()).toBeLessThanOrEqual(after.getTime());
   });
 
-  it('should upsert by callSid + toolName and keep createdAt while updating other fields', async () => {
-    const callSid = 'CA-background-call-2';
-    const toolName = 'aggregationTool';
+  it("should upsert by callSid + toolName and keep createdAt while updating other fields", async () => {
+    const callSid = "CA-background-call-2";
+    const toolName = "aggregationTool";
 
     const first = await upsertBackgroundToolResult({
       callSid,
       toolName,
-      status: 'pending',
+      status: "pending",
       result: null,
     });
 
@@ -65,7 +70,7 @@ describe('backgroundToolResults getters', () => {
     const second = await upsertBackgroundToolResult({
       callSid,
       toolName,
-      status: 'success',
+      status: "success",
       result: secondResultPayload,
       ttlMs: customTtlMs,
     });
@@ -74,12 +79,14 @@ describe('backgroundToolResults getters', () => {
     expect(second!._id.toHexString()).toBe(first!._id.toHexString());
     expect(second!.callSid).toBe(callSid);
     expect(second!.toolName).toBe(toolName);
-    expect(second!.status).toBe('success');
+    expect(second!.status).toBe("success");
     expect(second!.result).toEqual(secondResultPayload);
 
     expect(second!.createdAt.getTime()).toBe(firstCreatedAt.getTime());
 
-    expect(second!.updatedAt.getTime()).toBeGreaterThanOrEqual(firstUpdatedAt.getTime());
+    expect(second!.updatedAt.getTime()).toBeGreaterThanOrEqual(
+      firstUpdatedAt.getTime(),
+    );
     expect(second!.expiredAt.getTime()).not.toBe(firstExpiredAt.getTime());
 
     const ttlMs = second!.expiredAt.getTime() - second!.updatedAt.getTime();
@@ -87,15 +94,15 @@ describe('backgroundToolResults getters', () => {
     expect(ttlMs).toBeLessThanOrEqual(customTtlMs + 1000);
   });
 
-  it('should find background tool result by callSid and toolName', async () => {
-    const callSid = 'CA-background-call-3';
-    const toolName = 'fetchUserData';
+  it("should find background tool result by callSid and toolName", async () => {
+    const callSid = "CA-background-call-3";
+    const toolName = "fetchUserData";
 
     await upsertBackgroundToolResult({
       callSid,
       toolName,
-      status: 'success',
-      result: { foo: 'bar' },
+      status: "success",
+      result: { foo: "bar" },
     });
 
     const found = await findBackgroundToolResult(callSid, toolName);
@@ -104,18 +111,21 @@ describe('backgroundToolResults getters', () => {
     expect(found?.toolName).toBe(toolName);
   });
 
-  it('should return null when background tool result does not exist', async () => {
-    const found = await findBackgroundToolResult('non-existing-callSid', 'nonExistingTool');
+  it("should return null when background tool result does not exist", async () => {
+    const found = await findBackgroundToolResult(
+      "non-existing-callSid",
+      "nonExistingTool",
+    );
     expect(found).toBeNull();
   });
 
-  it('should return all background tool results for a callSid ordered by createdAt', async () => {
-    const callSid = 'CA-background-call-4';
+  it("should return all background tool results for a callSid ordered by createdAt", async () => {
+    const callSid = "CA-background-call-4";
 
     await upsertBackgroundToolResult({
       callSid,
-      toolName: 'toolA',
-      status: 'pending',
+      toolName: "toolA",
+      status: "pending",
       result: null,
     });
 
@@ -123,14 +133,15 @@ describe('backgroundToolResults getters', () => {
 
     await upsertBackgroundToolResult({
       callSid,
-      toolName: 'toolB',
-      status: 'success',
+      toolName: "toolB",
+      status: "success",
       result: { ok: true },
     });
 
     const results = await findBackgroundToolResultsByCallSid(callSid);
     expect(results).toHaveLength(2);
-    expect(results[0].createdAt.getTime()).toBeLessThanOrEqual(results[1].createdAt.getTime());
+    expect(results[0].createdAt.getTime()).toBeLessThanOrEqual(
+      results[1].createdAt.getTime(),
+    );
   });
 });
-

package/src/talkpilot/backgroundToolResults/backgroundToolResults.getters.ts

@@ -1,17 +1,18 @@
-import { Collection } from 'mongodb';
-import { getDb } from '../index';
+import { Collection } from "mongodb";
+import { getDb } from "../index";
 import {
   BackgroundToolResult,
   BackgroundToolResultDoc,
   UpsertBackgroundToolResultInput,
-} from './backgroundToolResults.types';
+} from "./backgroundToolResults.types";
 
-const getBackgroundToolResultsCollection = (): Collection<BackgroundToolResult> => {
-  return getDb().collection<BackgroundToolResult>('backgroundToolResults');
-};
+const getBackgroundToolResultsCollection =
+  (): Collection<BackgroundToolResult> => {
+    return getDb().collection<BackgroundToolResult>("backgroundToolResults");
+  };
 
 const upsertBackgroundToolResult = async (
-  input: UpsertBackgroundToolResultInput
+  input: UpsertBackgroundToolResultInput,
 ): Promise<BackgroundToolResultDoc | null> => {
   const collection = getBackgroundToolResultsCollection();
   const now = new Date();
@@ -35,7 +36,7 @@ const upsertBackgroundToolResult = async (
         createdAt: now,
       },
     },
-    { upsert: true }
+    { upsert: true },
   );
 
   return collection.findOne(filter);
@@ -43,14 +44,14 @@ const upsertBackgroundToolResult = async (
 
 const findBackgroundToolResult = async (
   callSid: string,
-  toolName: string
+  toolName: string,
 ): Promise<BackgroundToolResultDoc | null> => {
   const collection = getBackgroundToolResultsCollection();
   return collection.findOne({ callSid, toolName });
 };
 
 const findBackgroundToolResultsByCallSid = async (
-  callSid: string
+  callSid: string,
 ): Promise<BackgroundToolResultDoc[]> => {
   const collection = getBackgroundToolResultsCollection();
   return collection.find({ callSid }).sort({ createdAt: 1 }).toArray();
@@ -62,4 +63,3 @@ export {
   findBackgroundToolResult,
   findBackgroundToolResultsByCallSid,
 };
-

package/src/talkpilot/backgroundToolResults/backgroundToolResults.types.ts

@@ -1,6 +1,6 @@
-import { WithId } from 'mongodb';
+import { WithId } from "mongodb";
 
-export type BackgroundToolStatus = 'success' | 'pending' | 'error';
+export type BackgroundToolStatus = "success" | "pending" | "error";
 
 export interface BackgroundToolResult {
   callSid: string;
@@ -21,4 +21,3 @@ export interface UpsertBackgroundToolResultInput {
   status: BackgroundToolStatus;
   ttlMs?: number;
 }
-

package/src/talkpilot/backgroundToolResults/index.ts

@@ -1,2 +1,2 @@
-export * from './backgroundToolResults.getters';
-export type * from './backgroundToolResults.types';
+export * from "./backgroundToolResults.getters";
+export type * from "./backgroundToolResults.types";

package/src/talkpilot/calls/__tests__/callStats.utils.spec.ts

@@ -4,14 +4,17 @@ import {
   range,
   startOfDay,
   getCallsCollection,
-} from '../calls.getters';
-import { createIncomingCallDoc, createOutGoingCallDoc } from '../../../test-utils/factories';
+} from "../calls.getters";
+import {
+  createIncomingCallDoc,
+  createOutGoingCallDoc,
+} from "../../../test-utils/factories";
 
-describe('callStats.utils', () => {
-  describe('countCallsByPhoneInRange', () => {
-    it('counts outgoing calls for a phone within a date range', async () => {
-      const phone = '+972500000001';
-      const baseDate = new Date('2023-01-10T10:00:00Z');
+describe("callStats.utils", () => {
+  describe("countCallsByPhoneInRange", () => {
+    it("counts outgoing calls for a phone within a date range", async () => {
+      const phone = "+972500000001";
+      const baseDate = new Date("2023-01-10T10:00:00Z");
 
       const outgoingInside = createOutGoingCallDoc({
         customerPhoneNumber: phone,
@@ -27,16 +30,16 @@ describe('callStats.utils', () => {
       });
 
       await getCallsCollection().insertMany([
-        { ...outgoingInside, updatedAt: outgoingInside.createdAt, env: 'test' },
+        { ...outgoingInside, updatedAt: outgoingInside.createdAt, env: "test" },
         {
           ...outgoingOutsideBefore,
           updatedAt: outgoingOutsideBefore.createdAt,
-          env: 'test',
+          env: "test",
         },
         {
           ...outgoingOutsideAfter,
           updatedAt: outgoingOutsideAfter.createdAt,
-          env: 'test',
+          env: "test",
         },
       ]);
 
@@ -52,9 +55,9 @@ describe('callStats.utils', () => {
       expect(count).toBe(1);
     });
 
-    it('filters by incoming/outgoing flags', async () => {
-      const phone = '+972500000002';
-      const createdAt = new Date('2023-02-01T12:00:00Z');
+    it("filters by incoming/outgoing flags", async () => {
+      const phone = "+972500000002";
+      const createdAt = new Date("2023-02-01T12:00:00Z");
 
       const outgoing = createOutGoingCallDoc({
         customerPhoneNumber: phone,
@@ -66,8 +69,8 @@ describe('callStats.utils', () => {
       });
 
       await getCallsCollection().insertMany([
-        { ...outgoing, updatedAt: outgoing.createdAt, env: 'test' },
-        { ...incoming, updatedAt: incoming.createdAt, env: 'test' },
+        { ...outgoing, updatedAt: outgoing.createdAt, env: "test" },
+        { ...incoming, updatedAt: incoming.createdAt, env: "test" },
       ]);
 
       const outgoingCount = await countCallsByPhoneInRange(
@@ -86,9 +89,9 @@ describe('callStats.utils', () => {
     });
   });
 
-  describe('date helpers', () => {
-    it('startOfDay normalizes to midnight', () => {
-      const d = new Date('2023-03-10T15:30:45.000Z');
+  describe("date helpers", () => {
+    it("startOfDay normalizes to midnight", () => {
+      const d = new Date("2023-03-10T15:30:45.000Z");
       const s = startOfDay(d);
       expect(s.getUTCHours()).toBe(0);
       expect(s.getUTCMinutes()).toBe(0);
@@ -96,19 +99,16 @@ describe('callStats.utils', () => {
       expect(s.getUTCMilliseconds()).toBe(0);
     });
 
-    it('addDays shifts the date by given days', () => {
-      const d = new Date('2023-03-10T00:00:00.000Z');
+    it("addDays shifts the date by given days", () => {
+      const d = new Date("2023-03-10T00:00:00.000Z");
       expect(addDays(d, 1).getUTCDate()).toBe(11);
       expect(addDays(d, -1).getUTCDate()).toBe(9);
     });
 
-    it('range helpers produce expected bounds', () => {
-      const base = new Date('2023-03-15T10:00:00.000Z');
+    it("range helpers produce expected bounds", () => {
+      const base = new Date("2023-03-15T10:00:00.000Z");
 
-      const betweenRange = range.between(
-        addDays(base, -1),
-        addDays(base, 1),
-      );
+      const betweenRange = range.between(addDays(base, -1), addDays(base, 1));
       expect(betweenRange.since).toEqual(addDays(base, -1));
       expect(betweenRange.until).toEqual(addDays(base, 1));
 
@@ -125,4 +125,4 @@ describe('callStats.utils', () => {
       expect(startToNowRange.until).toBeInstanceOf(Date);
     });
   });
-})
+});

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

@@ -8,12 +8,12 @@ import {
   countCalls,
   getCallsByClientAndDateRange,
   getCallsCollection,
-} from '../calls.getters';
-import { ObjectId } from 'mongodb';
-import { createOutGoingCallDoc } from '../../../test-utils/factories';
+} from "../calls.getters";
+import { ObjectId } from "mongodb";
+import { createOutGoingCallDoc } from "../../../test-utils/factories";
 
-describe('db.calls', () => {
-  it('should return calls by flow', async () => {
+describe("db.calls", () => {
+  it("should return calls by flow", async () => {
     const flowId = new ObjectId();
     const call1 = createOutGoingCallDoc({ flowId });
     const call2 = createOutGoingCallDoc({ flowId });
@@ -26,11 +26,11 @@ describe('db.calls', () => {
     expect(result.length).toBe(2);
     expect(result).toMatchObject([
       { callSid: call1.callSid },
-      { callSid: call2.callSid }
+      { callSid: call2.callSid },
     ]);
   });
 
-  it('should get call by callSid', async () => {
+  it("should get call by callSid", async () => {
     const call = createOutGoingCallDoc();
     await createCallDoc(call);
 
@@ -40,39 +40,54 @@ describe('db.calls', () => {
     expect(result?.callSid).toBe(call.callSid);
   });
 
-  it('should get calls by client', async () => {
+  it("should get calls by client", async () => {
     const call = createOutGoingCallDoc();
     await createCallDoc(call);
 
     const result = await getCallsByClient(call.clientId);
 
-    expect(result.some(c => c.callSid === call.callSid)).toBe(true);
+    expect(result.some((c) => c.callSid === call.callSid)).toBe(true);
   });
 
-  it('should get calls by phone number', async () => {
+  it("should get calls by phone number", async () => {
     const call = createOutGoingCallDoc();
     await createCallDoc(call);
 
     const result = await getCallsByPhoneNumber(call.customerPhoneNumber);
 
-    expect(result.some(c => c.callSid === call.callSid)).toBe(true);
+    expect(result.some((c) => c.callSid === call.callSid)).toBe(true);
   });
 
-  describe('findCallsByQuery()', () => {
-    it('should find calls by status with limit and sort', async () => {
-      const clientId = 'client123';
-      const call1 = createOutGoingCallDoc({ clientId, status: 'completed' });
-      const call2 = createOutGoingCallDoc({ clientId, status: 'completed' });
-      const call3 = createOutGoingCallDoc({ clientId, status: 'busy' });
+  describe("findCallsByQuery()", () => {
+    it("should find calls by status with limit and sort", async () => {
+      const clientId = "client123";
+      const call1 = createOutGoingCallDoc({ clientId, status: "completed" });
+      const call2 = createOutGoingCallDoc({ clientId, status: "completed" });
+      const call3 = createOutGoingCallDoc({ clientId, status: "busy" });
 
       // We need to control createdAt to test sort. We'll insert directly.
-      await getCallsCollection().insertOne({ ...call1, createdAt: new Date('2023-01-01'), updatedAt: new Date(), env: 'test' });
-      await getCallsCollection().insertOne({ ...call2, createdAt: new Date('2023-01-02'), updatedAt: new Date(), env: 'test' });
-      await getCallsCollection().insertOne({ ...call3, createdAt: new Date(), updatedAt: new Date(), env: 'test' });
+      await getCallsCollection().insertOne({
+        ...call1,
+        createdAt: new Date("2023-01-01"),
+        updatedAt: new Date(),
+        env: "test",
+      });
+      await getCallsCollection().insertOne({
+        ...call2,
+        createdAt: new Date("2023-01-02"),
+        updatedAt: new Date(),
+        env: "test",
+      });
+      await getCallsCollection().insertOne({
+        ...call3,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        env: "test",
+      });
 
       const result = await findCallsByQuery(
-        { clientId, status: 'completed' },
-        { sort: { createdAt: -1 }, limit: 1 }
+        { clientId, status: "completed" },
+        { sort: { createdAt: -1 }, limit: 1 },
       );
 
       expect(result.length).toBe(1);
@@ -80,33 +95,58 @@ describe('db.calls', () => {
     });
   });
 
-  describe('countCalls()', () => {
-    it('should count calls matching query', async () => {
-      const clientId = 'countClient';
-      await createCallDoc(createOutGoingCallDoc({ clientId, status: 'completed' }));
-      await createCallDoc(createOutGoingCallDoc({ clientId, status: 'completed' }));
-      await createCallDoc(createOutGoingCallDoc({ clientId, status: 'failed' }));
+  describe("countCalls()", () => {
+    it("should count calls matching query", async () => {
+      const clientId = "countClient";
+      await createCallDoc(
+        createOutGoingCallDoc({ clientId, status: "completed" }),
+      );
+      await createCallDoc(
+        createOutGoingCallDoc({ clientId, status: "completed" }),
+      );
+      await createCallDoc(
+        createOutGoingCallDoc({ clientId, status: "failed" }),
+      );
 
-      const count = await countCalls({ clientId, status: 'completed' });
+      const count = await countCalls({ clientId, status: "completed" });
       expect(count).toBe(2);
     });
   });
 
-  describe('getCallsByClientAndDateRange()', () => {
-    it('should return calls within date range', async () => {
-      const clientId = 'dateRangeClient';
-      const startDate = new Date('2023-05-01');
-      const endDate = new Date('2023-05-31');
+  describe("getCallsByClientAndDateRange()", () => {
+    it("should return calls within date range", async () => {
+      const clientId = "dateRangeClient";
+      const startDate = new Date("2023-05-01");
+      const endDate = new Date("2023-05-31");
 
       const callInside = createOutGoingCallDoc({ clientId });
       const callBefore = createOutGoingCallDoc({ clientId });
       const callAfter = createOutGoingCallDoc({ clientId });
 
-      await getCallsCollection().insertOne({ ...callInside, createdAt: new Date('2023-05-15'), updatedAt: new Date(), env: 'test' });
-      await getCallsCollection().insertOne({ ...callBefore, createdAt: new Date('2023-04-30'), updatedAt: new Date(), env: 'test' });
-      await getCallsCollection().insertOne({ ...callAfter, createdAt: new Date('2023-06-01'), updatedAt: new Date(), env: 'test' });
-
-      const result = await getCallsByClientAndDateRange(clientId, startDate, endDate);
+      await getCallsCollection().insertOne({
+        ...callInside,
+        createdAt: new Date("2023-05-15"),
+        updatedAt: new Date(),
+        env: "test",
+      });
+      await getCallsCollection().insertOne({
+        ...callBefore,
+        createdAt: new Date("2023-04-30"),
+        updatedAt: new Date(),
+        env: "test",
+      });
+      await getCallsCollection().insertOne({
+        ...callAfter,
+        createdAt: new Date("2023-06-01"),
+        updatedAt: new Date(),
+        env: "test",
+      });
+
+      const result = await getCallsByClientAndDateRange(
+        clientId,
+        startDate,
+        endDate,
+      );
       expect(result.length).toBe(1);
       expect(result[0].callSid).toBe(callInside.callSid);
     });