@talkpilot/core-db 1.1.14 → 1.1.16

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

@@ -6,14 +6,14 @@ import {
   getClientPhoneData,
   createPhoneNumberEntity,
   createPurchasedPhoneNumber,
-} from '../phone_numbers.getter';
-import { getFlowsCollection } from '../../flows/flows.getter';
-import { createFlow, createPhoneNumber } from '../../../test-utils/factories';
-import { ObjectId } from 'mongodb';
-
-describe('db.phoneNumbers', () => {
-  describe('getPhoneDataByPhoneNumber', () => {
-    it('return phone number data with flow', async () => {
+} from "../phone_numbers.getter";
+import { getFlowsCollection } from "../../flows/flows.getter";
+import { createFlow, createPhoneNumber } from "../../../test-utils/factories";
+import { ObjectId } from "mongodb";
+
+describe("db.phoneNumbers", () => {
+  describe("getPhoneDataByPhoneNumber", () => {
+    it("return phone number data with flow", async () => {
       const flow = createFlow({
         clientId: "test-client-id",
         conversationSettings: {
@@ -129,9 +129,9 @@ describe('db.phoneNumbers', () => {
     });
   });
 
-  describe('getPhoneNumbersForFlows', () => {
-    it('returns all phone numbers for the client with flow ObjectIds, newest first', async () => {
-      const clientId = 'flowsClient';
+  describe("getPhoneNumbersForFlows", () => {
+    it("returns all phone numbers for the client with flow ObjectIds, newest first", async () => {
+      const clientId = "flowsClient";
       const flow1 = createFlow({ clientId });
       const flow2 = createFlow({ clientId });
       await getFlowsCollection().insertMany([flow1, flow2]);
@@ -139,16 +139,16 @@ describe('db.phoneNumbers', () => {
       const older = createPhoneNumber({
         client_id: clientId,
         flow_id: flow1._id,
-        phone_number: '+100',
+        phone_number: "+100",
         is_primary: true,
-        createdAt: new Date('2023-01-01'),
+        createdAt: new Date("2023-01-01"),
       });
       const newer = createPhoneNumber({
         client_id: clientId,
         flow_id: flow2._id,
-        phone_number: '+200',
+        phone_number: "+200",
         is_primary: false,
-        createdAt: new Date('2023-06-01'),
+        createdAt: new Date("2023-06-01"),
       });
 
       await getPhoneNumbersCollection().insertMany([older, newer]);
@@ -158,27 +158,30 @@ describe('db.phoneNumbers', () => {
       expect(result).toHaveLength(2);
       expect(result[0]).toEqual({
         flowId: String(flow2._id),
-        phoneNumber: '+200',
+        phoneNumber: "+200",
         isPrimary: false,
       });
       expect(result[1]).toEqual({
         flowId: String(flow1._id),
-        phoneNumber: '+100',
+        phoneNumber: "+100",
         isPrimary: true,
       });
     });
 
-    it('returns an empty array when the client has no phone numbers', async () => {
-      const result = await getPhoneNumbersForFlows('noSuchClient');
+    it("returns an empty array when the client has no phone numbers", async () => {
+      const result = await getPhoneNumbersForFlows("noSuchClient");
       expect(result).toEqual([]);
     });
 
-    it('does not include phone numbers for other clients', async () => {
-      const clientA = 'clientA';
-      const clientB = 'clientB';
+    it("does not include phone numbers for other clients", async () => {
+      const clientA = "clientA";
+      const clientB = "clientB";
       const flow = createFlow();
       await getFlowsCollection().insertOne(flow);
-      const phone = createPhoneNumber({ client_id: clientA, flow_id: flow._id });
+      const phone = createPhoneNumber({
+        client_id: clientA,
+        flow_id: flow._id,
+      });
       await getPhoneNumbersCollection().insertOne(phone);
 
       const result = await getPhoneNumbersForFlows(clientB);
@@ -186,9 +189,9 @@ describe('db.phoneNumbers', () => {
     });
   });
 
-  describe('createPhoneNumberEntity', () => {
-    it('creates first phone number as primary', async () => {
-      const clientId = 'newClient';
+  describe("createPhoneNumberEntity", () => {
+    it("creates first phone number as primary", async () => {
+      const clientId = "newClient";
       const flowId = new ObjectId().toHexString();
       const phoneNumber = "+123456789";
 
@@ -215,14 +218,14 @@ describe('db.phoneNumbers', () => {
     });
   });
 
-  describe('createPurchasedPhoneNumber', () => {
-    it('persists a phone_numbers document with provider payload and flow', async () => {
-      const clientId = 'purchasedClientDb';
+  describe("createPurchasedPhoneNumber", () => {
+    it("persists a phone_numbers document with provider payload and flow", async () => {
+      const clientId = "purchasedClientDb";
       const flowId = new ObjectId().toHexString();
-      const phoneNumber = '+15551234567';
+      const phoneNumber = "+15551234567";
       const providerPayload = {
-        provider: 'twilio' as const,
-        provider_sid: 'PNxxxxxxxx',
+        provider: "twilio" as const,
+        provider_sid: "PNxxxxxxxx",
       };
 
       await createPurchasedPhoneNumber(
@@ -233,13 +236,15 @@ describe('db.phoneNumbers', () => {
       );
 
       // Re-read from Mongo to confirm insert succeeded (not only the function return value).
-      const stored = await getPhoneNumbersCollection().findOne({ phone_number: phoneNumber });
+      const stored = await getPhoneNumbersCollection().findOne({
+        phone_number: phoneNumber,
+      });
       expect(stored).not.toBeNull();
       expect(stored).toMatchObject({
         phone_number: phoneNumber,
         client_id: clientId,
-        provider: 'twilio',
-        provider_sid: 'PNxxxxxxxx',
+        provider: "twilio",
+        provider_sid: "PNxxxxxxxx",
         flow_id: new ObjectId(flowId),
       });
     });

package/src/talkpilot/phone_numbers/index.ts

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

package/src/talkpilot/phone_numbers/phone_numbers.getter.ts

@@ -6,12 +6,12 @@ import {
   getFlowsCollection,
   ObjectId,
   findSubscriptions,
-} from '../index';
+} from "../index";
 import {
   ClientPhoneNumberForFlow,
   PhoneNumber,
   PhoneNumberWithFlow,
-  PurchasedPhoneProviderPayload
+  PurchasedPhoneProviderPayload,
 } from "./phone_numbers.types";
 
 export const getPhoneNumbersCollection = (): Collection<PhoneNumber> =>
@@ -140,13 +140,17 @@ export const createPurchasedPhoneNumber = async (
   await getPhoneNumbersCollection().insertOne(doc);
 
   const created = await getClientPhoneData(clientId, isPrimary);
-  if (!created) throw new Error('Failed to create phoneNumber');
+  if (!created) throw new Error("Failed to create phoneNumber");
   return created;
 };
 
-export const findClientByPhoneNumber = async (phoneNumber: string): Promise<Client> => {
-  const phoneData = await getPhoneNumbersCollection().findOne({ phone_number: phoneNumber });
-  if (!phoneData) throw new Error('Failed to get phone data');
+export const findClientByPhoneNumber = async (
+  phoneNumber: string,
+): Promise<Client> => {
+  const phoneData = await getPhoneNumbersCollection().findOne({
+    phone_number: phoneNumber,
+  });
+  if (!phoneData) throw new Error("Failed to get phone data");
   const clientId = phoneData.client_id;
   const client = await getClientsCollection().findOne({ clientId });
   if (!client) throw new Error("Failed to get client");

package/src/talkpilot/phone_numbers/phone_numbers.schema.ts

@@ -1,17 +1,17 @@
 export const phoneNumbersMongoSchema = {
-  bsonType: 'object',
-  required: ['client_id', 'phone_number'],
+  bsonType: "object",
+  required: ["client_id", "phone_number"],
   properties: {
-    _id: { bsonType: 'objectId' },
-    client_id: { bsonType: 'string' },
-    flow_id: { bsonType: ['objectId', 'string'] },
-    phone_number: { bsonType: 'string' },
-    is_primary: { bsonType: 'bool' },
-    provider: { bsonType: 'string' },
-    provider_sid: { bsonType: 'string' },
-    friendly_name: { bsonType: 'string' },
-    createdAt: { bsonType: 'date' },
-    updatedAt: { bsonType: 'date' },
+    _id: { bsonType: "objectId" },
+    client_id: { bsonType: "string" },
+    flow_id: { bsonType: ["objectId", "string"] },
+    phone_number: { bsonType: "string" },
+    is_primary: { bsonType: "bool" },
+    provider: { bsonType: "string" },
+    provider_sid: { bsonType: "string" },
+    friendly_name: { bsonType: "string" },
+    createdAt: { bsonType: "date" },
+    updatedAt: { bsonType: "date" },
   },
   additionalProperties: false,
 } as const;

package/src/talkpilot/phone_numbers/phone_numbers.types.ts

@@ -1,8 +1,8 @@
-import { ObjectId, WithId } from 'mongodb';
-import { Flow } from '../flows/flows.types';
+import { ObjectId, WithId } from "mongodb";
+import { Flow } from "../flows/flows.types";
 
 export type PurchasedPhoneProviderPayload = {
-  provider: 'twilio' | 'telnyx';
+  provider: "twilio" | "telnyx";
   provider_sid: string;
   friendly_name?: string;
 };
@@ -14,7 +14,7 @@ export type PhoneNumber = {
   phone_number: string;
   subscriptionId?: string;
   is_primary: boolean;
-  provider?: 'twilio' | 'telnyx';
+  provider?: "twilio" | "telnyx";
   provider_sid?: string;
   friendly_name?: string;
   createdAt: Date;

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

@@ -0,0 +1,44 @@
+import { getProductsCollection, getAllProducts } from "../products.getters";
+import { ObjectId } from "../../index";
+
+describe("products getters", () => {
+  it('should return the "products" collection', () => {
+    const collection = getProductsCollection();
+    expect(collection.collectionName).toBe("products");
+  });
+
+  it("should return all product documents", async () => {
+    await getProductsCollection().insertMany([
+      { _id: new ObjectId(), name: "Municipal" },
+      { _id: new ObjectId(), name: "Clinics" },
+    ]);
+
+    const results = await getAllProducts();
+    expect(results.length).toBeGreaterThanOrEqual(2);
+    expect(results.map((p) => p.name)).toEqual(
+      expect.arrayContaining(["Municipal", "Clinics"]),
+    );
+  });
+
+  it("should store and retrieve displayName locale map", async () => {
+    const id = new ObjectId();
+    await getProductsCollection().insertOne({
+      _id: id,
+      name: "Municipal",
+      displayName: { he: "עירייה", en: "Municipal" },
+    });
+
+    const results = await getAllProducts();
+    const saved = results.find((p) => p._id.equals(id));
+    expect(saved?.displayName).toEqual({ he: "עירייה", en: "Municipal" });
+  });
+
+  it("should return products without displayName without error", async () => {
+    const id = new ObjectId();
+    await getProductsCollection().insertOne({ _id: id, name: "Rcure" });
+
+    const results = await getAllProducts();
+    const saved = results.find((p) => p._id.equals(id));
+    expect(saved?.displayName).toBeUndefined();
+  });
+});

package/src/talkpilot/products/index.ts

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

package/src/talkpilot/products/products.getters.ts

@@ -0,0 +1,12 @@
+import { Collection, WithId } from "mongodb";
+import { getDb } from "../index";
+import type { Product } from "./products.types";
+
+export const getProductsCollection = (): Collection<Product> => {
+  return getDb().collection<Product>("products");
+};
+
+/** Returns all product documents */
+export const getAllProducts = (): Promise<WithId<Product>[]> => {
+  return getProductsCollection().find().toArray();
+};

package/src/talkpilot/products/products.types.ts

@@ -0,0 +1,9 @@
+import { ObjectId } from "mongodb";
+
+export type Product = {
+  _id: ObjectId;
+  /** Internal product name */
+  name: string;
+  /** Map from language name to display name, e.g. {en, Municipal} */
+  displayName?: Record<string, string>;
+};

package/src/talkpilot/results/index.ts

@@ -1,5 +1,7 @@
 export {
   getResultsCollection,
   initializeResultDocument,
+  findResultById,
+  findResultByCallSid,
 } from "./results.getter";
 export type * from "./results.types";

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

@@ -1,5 +1,5 @@
-import type { Collection } from "mongodb";
-import { getDb, ObjectId, Session } from "../index";
+import { Collection, ObjectId } from "mongodb";
+import { getDb, Session } from "../index";
 import type { Result } from "./results.types";
 
 export const getResultsCollection = (): Collection<Result> =>
@@ -25,3 +25,15 @@ export const initializeResultDocument = async (
   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/retry_analyze/__tests__/retryAnalyze.getters.spec.ts

@@ -0,0 +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 },
+        },
+      );
+    });
+  });
+});

package/src/talkpilot/retry_analyze/index.ts

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

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

@@ -0,0 +1,84 @@
+import { Collection, ObjectId } from "mongodb";
+import { getDb } from "../index";
+import type { RetryAnalyzeDoc, RetryAnalyzeWithId } from "./retryAnalyze.types";
+
+const COLLECTION_NAME = "retryAnalyze";
+
+export const getRetryAnalyzeCollection = (): Collection<RetryAnalyzeDoc> => {
+  return getDb().collection<RetryAnalyzeDoc>(COLLECTION_NAME);
+};
+
+export const getAllRetryAnalyzeDocs = async (): Promise<
+  RetryAnalyzeWithId[]
+> => {
+  return getRetryAnalyzeCollection()
+    .find({
+      $or: [{ retry: { $lt: 5 } }, { retry: { $exists: false } }],
+    })
+    .toArray();
+};
+
+export const insertRetryAnalyzeDoc = async (
+  doc: Omit<RetryAnalyzeDoc, "_id">,
+): Promise<ObjectId> => {
+  const result = await getRetryAnalyzeCollection().insertOne(doc);
+  return result.insertedId;
+};
+
+export const upsertRetryAnalyzeDoc = async (
+  doc: Pick<RetryAnalyzeDoc, "callSid" | "errorLog" | "clientId">,
+): Promise<ObjectId | null> => {
+  const now = new Date();
+  const result = await getRetryAnalyzeCollection().updateOne(
+    { callSid: doc.callSid },
+    {
+      $set: {
+        errorLog: doc.errorLog,
+        updatedAt: now,
+      },
+      $setOnInsert: {
+        createdAt: now,
+        clientId: doc.clientId,
+        retry: 0,
+      },
+    },
+    { upsert: true },
+  );
+
+  if (result.matchedCount > 0) {
+    await getRetryAnalyzeCollection().updateOne(
+      { callSid: doc.callSid },
+      { $inc: { retry: 1 } },
+    );
+  }
+
+  return result.upsertedId || null;
+};
+
+export const deleteRetryAnalyzeDocById = async (
+  id: ObjectId,
+): Promise<boolean> => {
+  const result = await getRetryAnalyzeCollection().deleteOne({ _id: id });
+  return result.deletedCount === 1;
+};
+
+export const deleteRetryAnalyzeDocByCallSid = async (
+  callSid: string,
+): Promise<boolean> => {
+  const result = await getRetryAnalyzeCollection().deleteOne({ callSid });
+  return result.deletedCount === 1;
+};
+
+export const updateRetryAnalyzeErrorLog = async (
+  id: ObjectId,
+  errorLog: string,
+): Promise<boolean> => {
+  const result = await getRetryAnalyzeCollection().updateOne(
+    { _id: id },
+    {
+      $set: { errorLog, updatedAt: new Date() },
+      $inc: { retry: 1 },
+    },
+  );
+  return result.modifiedCount === 1;
+};

package/src/talkpilot/retry_analyze/retryAnalyze.types.ts

@@ -0,0 +1,13 @@
+import { ObjectId, WithId } from "mongodb";
+
+export type RetryAnalyzeDoc = {
+  _id?: ObjectId;
+  callSid: string;
+  retry: number;
+  clientId: string;
+  errorLog: string;
+  updatedAt: Date;
+  createdAt: Date;
+};
+
+export type RetryAnalyzeWithId = WithId<RetryAnalyzeDoc>;

package/src/test-utils/db-utils.ts

@@ -1,6 +1,6 @@
 import { MongoMemoryServer } from "mongodb-memory-server";
 import { MongoClient, Db } from "mongodb";
-import { setDb, setMunicipalDataDb } from "../index";
+import { setDb, setMunicipalDataDb, setWebsitalkDb } from "../index";
 
 let mongoServer: MongoMemoryServer;
 let client: MongoClient;
@@ -13,8 +13,10 @@ export async function initTestDb(): Promise<Db> {
   await client.connect();
   const talkpilotDb = client.db();
   const municipalDb = client.db("municipal-data");
+  const websitalkDb = client.db("website-talk");
   setDb(talkpilotDb);
   setMunicipalDataDb(municipalDb);
+  setWebsitalkDb(websitalkDb);
   return talkpilotDb;
 }
 

package/src/test-utils/factories/index.ts

@@ -3,10 +3,13 @@ export * from "./talkpilot/calls";
 export * from "./talkpilot/clientAudioBuffers";
 export * from "./talkpilot/clientsConfig";
 export * from "./talkpilot/flows";
+export * from "./talkpilot/contextNotes";
 export * from "./talkpilot/groups";
 export * from "./talkpilot/phone_numbers";
 export * from "./talkpilot/sessions";
 export * from "./municipal/cities";
 export * from "./municipal/departmentsSubjects";
+export * from "./municipal/muniIssues";
 export * from "./municipal/streets";
 export * from "./municipal/tickets";
+export * from "./websitalk/scans";