@talkpilot/core-db 1.2.0 → 1.2.1

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

@@ -1,252 +1,252 @@
-import {
-  createCallDoc,
-  getCallsByFlow,
-  getCallsByClient,
-  getCallsByPhoneNumber,
-  getCallByCallSid,
-  findCallsByQuery,
-  countCalls,
-  getCallsByClientAndDateRange,
-  getCallsCollection,
-  pushToolExecution,
-} from "../calls.getters";
-import type { ToolExecution } from '../calls.types';
-import { ObjectId } from "mongodb";
-import { createOutGoingCallDoc } from "../../../test-utils/factories";
-
-describe("db.calls", () => {
-  it("should return calls by flow", async () => {
-    const flowId = new ObjectId();
-    const call1 = createOutGoingCallDoc({ flowId });
-    const call2 = createOutGoingCallDoc({ flowId });
-
-    await createCallDoc(call1);
-    await createCallDoc(call2);
-
-    const result = await getCallsByFlow(flowId);
-
-    expect(result.length).toBe(2);
-    expect(result).toMatchObject([
-      { callSid: call1.callSid },
-      { callSid: call2.callSid },
-    ]);
-  });
-
-  it("should get call by callSid", async () => {
-    const call = createOutGoingCallDoc();
-    await createCallDoc(call);
-
-    const result = await getCallByCallSid(call.callSid);
-
-    expect(result).toBeDefined();
-    expect(result?.callSid).toBe(call.callSid);
-  });
-
-  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);
-  });
-
-  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);
-  });
-
-  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",
-      });
-
-      const result = await findCallsByQuery(
-        { clientId, status: "completed" },
-        { sort: { createdAt: -1 }, limit: 1 },
-      );
-
-      expect(result.length).toBe(1);
-      expect(result[0].callSid).toBe(call2.callSid);
-    });
-  });
-
-  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" });
-      expect(count).toBe(2);
-    });
-  });
-
-  describe('pushToolExecution()', () => {
-    let callSid: string;
-
-    beforeEach(async () => {
-      const call = createOutGoingCallDoc();
-      await createCallDoc(call);
-      callSid = call.callSid;
-    });
-
-    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',
-      httpStatus: 200,
-      ...overrides,
-    });
-
-    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',
-        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' });
-
-      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']);
-    });
-
-    it('should store an internal tool execution', async () => {
-      const execution: ToolExecution = {
-        toolName: 'endFlow',
-        executedAt: new Date(),
-        durationMs: 5,
-        args: {},
-        meta: { kind: 'internal' },
-        status: 'success',
-      };
-
-      await pushToolExecution(callSid, execution);
-
-      const result = await getCallByCallSid(callSid);
-      expect(result?.toolExecutions?.[0]).toMatchObject({
-        toolName: 'endFlow',
-        meta: { kind: 'internal' },
-      });
-    });
-
-    it('should store redacted args for sensitive tools', async () => {
-      const execution = makeHttpExecution({ args: { _redacted: true } });
-      await pushToolExecution(callSid, execution);
-
-      const result = await getCallByCallSid(callSid);
-      expect(result?.toolExecutions?.[0].args).toEqual({ _redacted: true });
-    });
-
-    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 });
-    });
-
-    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 () => {
-      const execution = makeHttpExecution({
-        response: { userId: '123', status: 'sent' },
-      });
-      await pushToolExecution(callSid, execution);
-
-      const result = await getCallByCallSid(callSid);
-      expect(result?.toolExecutions?.[0].response).toEqual({ userId: '123', status: 'sent' });
-    });
-  });
-
-  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,
-      );
-      expect(result.length).toBe(1);
-      expect(result[0].callSid).toBe(callInside.callSid);
-    });
-  });
-});
+import {
+  createCallDoc,
+  getCallsByFlow,
+  getCallsByClient,
+  getCallsByPhoneNumber,
+  getCallByCallSid,
+  findCallsByQuery,
+  countCalls,
+  getCallsByClientAndDateRange,
+  getCallsCollection,
+  pushToolExecution,
+} from "../calls.getters";
+import type { ToolExecution } from '../calls.types';
+import { ObjectId } from "mongodb";
+import { createOutGoingCallDoc } from "../../../test-utils/factories";
+
+describe("db.calls", () => {
+  it("should return calls by flow", async () => {
+    const flowId = new ObjectId();
+    const call1 = createOutGoingCallDoc({ flowId });
+    const call2 = createOutGoingCallDoc({ flowId });
+
+    await createCallDoc(call1);
+    await createCallDoc(call2);
+
+    const result = await getCallsByFlow(flowId);
+
+    expect(result.length).toBe(2);
+    expect(result).toMatchObject([
+      { callSid: call1.callSid },
+      { callSid: call2.callSid },
+    ]);
+  });
+
+  it("should get call by callSid", async () => {
+    const call = createOutGoingCallDoc();
+    await createCallDoc(call);
+
+    const result = await getCallByCallSid(call.callSid);
+
+    expect(result).toBeDefined();
+    expect(result?.callSid).toBe(call.callSid);
+  });
+
+  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);
+  });
+
+  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);
+  });
+
+  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",
+      });
+
+      const result = await findCallsByQuery(
+        { clientId, status: "completed" },
+        { sort: { createdAt: -1 }, limit: 1 },
+      );
+
+      expect(result.length).toBe(1);
+      expect(result[0].callSid).toBe(call2.callSid);
+    });
+  });
+
+  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" });
+      expect(count).toBe(2);
+    });
+  });
+
+  describe('pushToolExecution()', () => {
+    let callSid: string;
+
+    beforeEach(async () => {
+      const call = createOutGoingCallDoc();
+      await createCallDoc(call);
+      callSid = call.callSid;
+    });
+
+    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',
+      httpStatus: 200,
+      ...overrides,
+    });
+
+    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',
+        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' });
+
+      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']);
+    });
+
+    it('should store an internal tool execution', async () => {
+      const execution: ToolExecution = {
+        toolName: 'endFlow',
+        executedAt: new Date(),
+        durationMs: 5,
+        args: {},
+        meta: { kind: 'internal' },
+        status: 'success',
+      };
+
+      await pushToolExecution(callSid, execution);
+
+      const result = await getCallByCallSid(callSid);
+      expect(result?.toolExecutions?.[0]).toMatchObject({
+        toolName: 'endFlow',
+        meta: { kind: 'internal' },
+      });
+    });
+
+    it('should store redacted args for sensitive tools', async () => {
+      const execution = makeHttpExecution({ args: { _redacted: true } });
+      await pushToolExecution(callSid, execution);
+
+      const result = await getCallByCallSid(callSid);
+      expect(result?.toolExecutions?.[0].args).toEqual({ _redacted: true });
+    });
+
+    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 });
+    });
+
+    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 () => {
+      const execution = makeHttpExecution({
+        response: { userId: '123', status: 'sent' },
+      });
+      await pushToolExecution(callSid, execution);
+
+      const result = await getCallByCallSid(callSid);
+      expect(result?.toolExecutions?.[0].response).toEqual({ userId: '123', status: 'sent' });
+    });
+  });
+
+  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,
+      );
+      expect(result.length).toBe(1);
+      expect(result[0].callSid).toBe(callInside.callSid);
+    });
+  });
+});