@talkpilot/core-db 1.1.6 → 1.1.8

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,28 +3,23 @@ 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();
@@ -47,14 +42,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,
     });
 
@@ -70,7 +65,7 @@ describe("backgroundToolResults getters", () => {
     const second = await upsertBackgroundToolResult({
       callSid,
       toolName,
-      status: "success",
+      status: 'success',
       result: secondResultPayload,
       ttlMs: customTtlMs,
     });
@@ -79,14 +74,12 @@ 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();
@@ -94,15 +87,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);
@@ -111,21 +104,18 @@ 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,
     });
 
@@ -133,15 +123,14 @@ 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,18 +1,17 @@
-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();
@@ -36,7 +35,7 @@ const upsertBackgroundToolResult = async (
         createdAt: now,
       },
     },
-    { upsert: true },
+    { upsert: true }
   );
 
   return collection.findOne(filter);
@@ -44,14 +43,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();
@@ -63,3 +62,4 @@ 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,3 +21,4 @@ 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,17 +4,14 @@ 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,
@@ -30,16 +27,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',
         },
       ]);
 
@@ -55,9 +52,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,
@@ -69,8 +66,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(
@@ -89,9 +86,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);
@@ -99,16 +96,19 @@ 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,54 +40,39 @@ 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);
@@ -95,58 +80,33 @@ 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);
     });