@talkpilot/core-db 1.3.53 → 1.3.55

package/src/talkpilot/results/results.getter.ts

@@ -1,39 +1,39 @@
-import { Collection, ObjectId } from "mongodb";
-import { getDb, Session } from "../index";
-import type { Result } from "./results.types";
-
-export const getResultsCollection = (): Collection<Result> =>
-  getDb().collection<Result>("results");
-
-export const createRunId = (): string => {
-  return `run_${new ObjectId().toString()}`;
-};
-
-export const initializeResultDocument = async (
-  clientId: string,
-  session?: Session,
-): Promise<Result> => {
-  const { insertedId } = await getResultsCollection().insertOne({
-    runId: createRunId(),
-    date: new Date(),
-    calls: [],
-    sessionId: session ? session._id!.toString() : "incomingCall",
-    sessionName: session ? session.session_name : "incomingCall",
-    clientId,
-  });
-  const result = await getResultsCollection().findOne({ _id: insertedId });
-  if (!result) throw new Error("Failed to initialized result");
-  return result;
-};
-
-export const findResultById = async (
-  resultId: string | ObjectId,
-): Promise<Result | null> => {
-  return getResultsCollection().findOne({ _id: new ObjectId(resultId) });
-};
-
-export const findResultByCallSid = async (
-  callSid: string,
-): Promise<Result | null> => {
-  return getResultsCollection().findOne({ "calls.callSid": callSid });
-};
+import { Collection, ObjectId } from "mongodb";
+import { getDb, Session } from "../index";
+import type { Result } from "./results.types";
+
+export const getResultsCollection = (): Collection<Result> =>
+  getDb().collection<Result>("results");
+
+export const createRunId = (): string => {
+  return `run_${new ObjectId().toString()}`;
+};
+
+export const initializeResultDocument = async (
+  clientId: string,
+  session?: Session,
+): Promise<Result> => {
+  const { insertedId } = await getResultsCollection().insertOne({
+    runId: createRunId(),
+    date: new Date(),
+    calls: [],
+    sessionId: session ? session._id!.toString() : "incomingCall",
+    sessionName: session ? session.session_name : "incomingCall",
+    clientId,
+  });
+  const result = await getResultsCollection().findOne({ _id: insertedId });
+  if (!result) throw new Error("Failed to initialized result");
+  return result;
+};
+
+export const findResultById = async (
+  resultId: string | ObjectId,
+): Promise<Result | null> => {
+  return getResultsCollection().findOne({ _id: new ObjectId(resultId) });
+};
+
+export const findResultByCallSid = async (
+  callSid: string,
+): Promise<Result | null> => {
+  return getResultsCollection().findOne({ "calls.callSid": callSid });
+};

package/src/talkpilot/results/results.schema.ts

@@ -1,25 +1,25 @@
-export const resultMongoSchema = {
-  bsonType: "object",
-  required: [
-    "_id",
-    "sessionId",
-    "status",
-    "callLength",
-    "date",
-    "userAnswer",
-    "systemSessionId",
-    "clientId",
-  ],
-  properties: {
-    _id: { bsonType: "objectId" },
-    sessionId: { bsonType: "string" },
-    status: { bsonType: "string" },
-    callLength: { bsonType: "string" },
-    date: { bsonType: "date" },
-    userAnswer: { bsonType: "string" },
-    recordingUrl: { bsonType: ["string", "null"] },
-    systemSessionId: { bsonType: "string" },
-    clientId: { bsonType: "string" },
-  },
-  additionalProperties: false,
-} as const;
+export const resultMongoSchema = {
+  bsonType: "object",
+  required: [
+    "_id",
+    "sessionId",
+    "status",
+    "callLength",
+    "date",
+    "userAnswer",
+    "systemSessionId",
+    "clientId",
+  ],
+  properties: {
+    _id: { bsonType: "objectId" },
+    sessionId: { bsonType: "string" },
+    status: { bsonType: "string" },
+    callLength: { bsonType: "string" },
+    date: { bsonType: "date" },
+    userAnswer: { bsonType: "string" },
+    recordingUrl: { bsonType: ["string", "null"] },
+    systemSessionId: { bsonType: "string" },
+    clientId: { bsonType: "string" },
+  },
+  additionalProperties: false,
+} as const;

package/src/talkpilot/results/results.types.ts

@@ -1,34 +1,34 @@
-import { ObjectId } from "mongodb";
-
-export interface Result {
-  _id?: ObjectId;
-  calls: CallResult[];
-  clientId: string;
-  date: Date;
-  runId: string;
-  sessionId: ObjectId | string;
-  sessionName: string;
-}
-
-export interface CallResult {
-  callSid: string;
-  status: string;
-  date: Date;
-  statuses: string[];
-  userAnswer: string | null;
-  color: string | null;
-  name: string | null;
-  callLength: string;
-  answeredBy: string | null;
-  to: string;
-  from: string;
-  transcription: TranscriptionSegment[];
-  flowId: ObjectId | string;
-  recordingUrl: string | null;
-  agentHungUp?: boolean;
-  endReason?: string;
-}
-
-export type TranscriptionSegment =
-  | { assistant: string; user?: never }
-  | { user: string; assistant?: never };
+import { ObjectId } from "mongodb";
+
+export interface Result {
+  _id?: ObjectId;
+  calls: CallResult[];
+  clientId: string;
+  date: Date;
+  runId: string;
+  sessionId: ObjectId | string;
+  sessionName: string;
+}
+
+export interface CallResult {
+  callSid: string;
+  status: string;
+  date: Date;
+  statuses: string[];
+  userAnswer: string | null;
+  color: string | null;
+  name: string | null;
+  callLength: string;
+  answeredBy: string | null;
+  to: string;
+  from: string;
+  transcription: TranscriptionSegment[];
+  flowId: ObjectId | string;
+  recordingUrl: string | null;
+  agentHungUp?: boolean;
+  endReason?: string;
+}
+
+export type TranscriptionSegment =
+  | { assistant: string; user?: never }
+  | { user: string; assistant?: never };

package/src/talkpilot/retry_analyze/__tests__/retryAnalyze.getters.spec.ts

@@ -1,156 +1,156 @@
-import { describe, it, expect, beforeEach, jest } from "@jest/globals";
-import { ObjectId } from "mongodb";
-import {
-  getAllRetryAnalyzeDocs,
-  upsertRetryAnalyzeDoc,
-  insertRetryAnalyzeDoc,
-  updateRetryAnalyzeErrorLog,
-} from "../retryAnalyze.getters";
-import { setDb } from "../../index";
-import { RetryAnalyzeDoc } from "../retryAnalyze.types";
-
-describe("retryAnalyze.getters", () => {
-  let mockCollection: any;
-  let mockDb: any;
-
-  beforeEach(() => {
-    mockCollection = {
-      find: jest.fn().mockReturnThis(),
-      toArray: jest.fn(),
-      insertOne: jest.fn(),
-      updateOne: jest.fn(),
-      deleteOne: jest.fn(),
-    };
-    mockDb = {
-      collection: jest.fn().mockReturnValue(mockCollection),
-    };
-    setDb(mockDb as any);
-  });
-
-  describe("getAllRetryAnalyzeDocs", () => {
-    it("should filter documents with retry >= 5 and include old format docs", async () => {
-      const mockDocs = [
-        { _id: new ObjectId(), callSid: "old-doc", errorLog: "{}" },
-        { _id: new ObjectId(), callSid: "retry-1", errorLog: "{}", retry: 1 },
-        { _id: new ObjectId(), callSid: "retry-5", errorLog: "{}", retry: 5 },
-      ];
-
-      mockCollection.toArray.mockResolvedValue(mockDocs);
-
-      await getAllRetryAnalyzeDocs();
-
-      expect(mockCollection.find).toHaveBeenCalledWith({
-        $or: [{ retry: { $lt: 5 } }, { retry: { $exists: false } }],
-      });
-    });
-  });
-
-  describe("upsertRetryAnalyzeDoc", () => {
-    const error429 = JSON.stringify({
-      error: {
-        code: 429,
-        message: "Resource exhausted. Please try again later.",
-        status: "RESOURCE_EXHAUSTED",
-      },
-    });
-
-    it("should upsert document correctly with $setOnInsert for clientId and createdAt", async () => {
-      const doc = {
-        callSid: "call-123",
-        errorLog: error429,
-        clientId: "client-1",
-      };
-
-      mockCollection.updateOne.mockResolvedValue({
-        upsertedId: new ObjectId(),
-        matchedCount: 0,
-      });
-
-      await upsertRetryAnalyzeDoc(doc);
-
-      expect(mockCollection.updateOne).toHaveBeenCalledWith(
-        { callSid: doc.callSid },
-        expect.objectContaining({
-          $set: expect.objectContaining({
-            errorLog: doc.errorLog,
-            updatedAt: expect.any(Date),
-          }),
-          $setOnInsert: expect.objectContaining({
-            createdAt: expect.any(Date),
-            clientId: doc.clientId,
-            retry: 0,
-          }),
-        }),
-        { upsert: true },
-      );
-    });
-
-    it("should ensure only one document exists for the same callSid even on multiple failures", async () => {
-      const doc = {
-        callSid: "CA_SINGLE_DOC",
-        errorLog: error429,
-        clientId: "client-1",
-      };
-
-      mockCollection.updateOne
-        .mockResolvedValueOnce({ upsertedId: new ObjectId(), matchedCount: 0 })
-        .mockResolvedValueOnce({ upsertedId: null, matchedCount: 1 });
-
-      await upsertRetryAnalyzeDoc(doc);
-      await upsertRetryAnalyzeDoc(doc);
-
-      expect(mockCollection.updateOne).toHaveBeenCalledWith(
-        { callSid: doc.callSid },
-        expect.objectContaining({
-          $setOnInsert: expect.objectContaining({ retry: 0 }),
-        }),
-        { upsert: true },
-      );
-
-      expect(mockCollection.updateOne).toHaveBeenLastCalledWith(
-        { callSid: doc.callSid },
-        { $inc: { retry: 1 } },
-      );
-    });
-  });
-
-  describe("insertRetryAnalyzeDoc", () => {
-    it("should perform a simple insert", async () => {
-      const doc: Omit<RetryAnalyzeDoc, "_id"> = {
-        callSid: "call-456",
-        retry: 0,
-        clientId: "client-2",
-        errorLog: "err",
-        updatedAt: new Date(),
-        createdAt: new Date(),
-      };
-
-      mockCollection.insertOne.mockResolvedValue({
-        insertedId: new ObjectId(),
-      });
-
-      await insertRetryAnalyzeDoc(doc);
-
-      expect(mockCollection.insertOne).toHaveBeenCalledWith(doc);
-    });
-  });
-
-  describe("updateRetryAnalyzeErrorLog", () => {
-    it("should update errorLog, updatedAt and increment retry", async () => {
-      const id = new ObjectId();
-      const errorLog = "new retry error";
-
-      mockCollection.updateOne.mockResolvedValue({ modifiedCount: 1 });
-
-      await updateRetryAnalyzeErrorLog(id, errorLog);
-
-      expect(mockCollection.updateOne).toHaveBeenCalledWith(
-        { _id: id },
-        {
-          $set: { errorLog, updatedAt: expect.any(Date) },
-          $inc: { retry: 1 },
-        },
-      );
-    });
-  });
-});
+import { describe, it, expect, beforeEach, jest } from "@jest/globals";
+import { ObjectId } from "mongodb";
+import {
+  getAllRetryAnalyzeDocs,
+  upsertRetryAnalyzeDoc,
+  insertRetryAnalyzeDoc,
+  updateRetryAnalyzeErrorLog,
+} from "../retryAnalyze.getters";
+import { setDb } from "../../index";
+import { RetryAnalyzeDoc } from "../retryAnalyze.types";
+
+describe("retryAnalyze.getters", () => {
+  let mockCollection: any;
+  let mockDb: any;
+
+  beforeEach(() => {
+    mockCollection = {
+      find: jest.fn().mockReturnThis(),
+      toArray: jest.fn(),
+      insertOne: jest.fn(),
+      updateOne: jest.fn(),
+      deleteOne: jest.fn(),
+    };
+    mockDb = {
+      collection: jest.fn().mockReturnValue(mockCollection),
+    };
+    setDb(mockDb as any);
+  });
+
+  describe("getAllRetryAnalyzeDocs", () => {
+    it("should filter documents with retry >= 5 and include old format docs", async () => {
+      const mockDocs = [
+        { _id: new ObjectId(), callSid: "old-doc", errorLog: "{}" },
+        { _id: new ObjectId(), callSid: "retry-1", errorLog: "{}", retry: 1 },
+        { _id: new ObjectId(), callSid: "retry-5", errorLog: "{}", retry: 5 },
+      ];
+
+      mockCollection.toArray.mockResolvedValue(mockDocs);
+
+      await getAllRetryAnalyzeDocs();
+
+      expect(mockCollection.find).toHaveBeenCalledWith({
+        $or: [{ retry: { $lt: 5 } }, { retry: { $exists: false } }],
+      });
+    });
+  });
+
+  describe("upsertRetryAnalyzeDoc", () => {
+    const error429 = JSON.stringify({
+      error: {
+        code: 429,
+        message: "Resource exhausted. Please try again later.",
+        status: "RESOURCE_EXHAUSTED",
+      },
+    });
+
+    it("should upsert document correctly with $setOnInsert for clientId and createdAt", async () => {
+      const doc = {
+        callSid: "call-123",
+        errorLog: error429,
+        clientId: "client-1",
+      };
+
+      mockCollection.updateOne.mockResolvedValue({
+        upsertedId: new ObjectId(),
+        matchedCount: 0,
+      });
+
+      await upsertRetryAnalyzeDoc(doc);
+
+      expect(mockCollection.updateOne).toHaveBeenCalledWith(
+        { callSid: doc.callSid },
+        expect.objectContaining({
+          $set: expect.objectContaining({
+            errorLog: doc.errorLog,
+            updatedAt: expect.any(Date),
+          }),
+          $setOnInsert: expect.objectContaining({
+            createdAt: expect.any(Date),
+            clientId: doc.clientId,
+            retry: 0,
+          }),
+        }),
+        { upsert: true },
+      );
+    });
+
+    it("should ensure only one document exists for the same callSid even on multiple failures", async () => {
+      const doc = {
+        callSid: "CA_SINGLE_DOC",
+        errorLog: error429,
+        clientId: "client-1",
+      };
+
+      mockCollection.updateOne
+        .mockResolvedValueOnce({ upsertedId: new ObjectId(), matchedCount: 0 })
+        .mockResolvedValueOnce({ upsertedId: null, matchedCount: 1 });
+
+      await upsertRetryAnalyzeDoc(doc);
+      await upsertRetryAnalyzeDoc(doc);
+
+      expect(mockCollection.updateOne).toHaveBeenCalledWith(
+        { callSid: doc.callSid },
+        expect.objectContaining({
+          $setOnInsert: expect.objectContaining({ retry: 0 }),
+        }),
+        { upsert: true },
+      );
+
+      expect(mockCollection.updateOne).toHaveBeenLastCalledWith(
+        { callSid: doc.callSid },
+        { $inc: { retry: 1 } },
+      );
+    });
+  });
+
+  describe("insertRetryAnalyzeDoc", () => {
+    it("should perform a simple insert", async () => {
+      const doc: Omit<RetryAnalyzeDoc, "_id"> = {
+        callSid: "call-456",
+        retry: 0,
+        clientId: "client-2",
+        errorLog: "err",
+        updatedAt: new Date(),
+        createdAt: new Date(),
+      };
+
+      mockCollection.insertOne.mockResolvedValue({
+        insertedId: new ObjectId(),
+      });
+
+      await insertRetryAnalyzeDoc(doc);
+
+      expect(mockCollection.insertOne).toHaveBeenCalledWith(doc);
+    });
+  });
+
+  describe("updateRetryAnalyzeErrorLog", () => {
+    it("should update errorLog, updatedAt and increment retry", async () => {
+      const id = new ObjectId();
+      const errorLog = "new retry error";
+
+      mockCollection.updateOne.mockResolvedValue({ modifiedCount: 1 });
+
+      await updateRetryAnalyzeErrorLog(id, errorLog);
+
+      expect(mockCollection.updateOne).toHaveBeenCalledWith(
+        { _id: id },
+        {
+          $set: { errorLog, updatedAt: expect.any(Date) },
+          $inc: { retry: 1 },
+        },
+      );
+    });
+  });
+});

package/src/talkpilot/retry_analyze/index.ts

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