@talkpilot/core-db 1.3.50 → 1.3.52

package/src/talkpilot/clientAudioBuffers/clientAudioBuffer.getters.ts

@@ -1,117 +1,117 @@
-import { getDb } from "../index";
-import {
-  ClientAudioBufferDoc,
-  ClientAudioBufferType,
-  CreateAudioBufferInput,
-} from "./clientsAudioBuffers.types";
-import { Collection, InsertOneResult, DeleteResult } from "mongodb";
-
-const getClientAudioBuffersCollection =
-  (): Collection<ClientAudioBufferType> => {
-    return getDb().collection<ClientAudioBufferType>("clientAudioBuffers");
-  };
-
-/**
- * Deletes all audio buffers associated with a specific callSid.
- * Useful for clearing context between different tickets in the same call.
- */
-const deleteAudioBuffersByCallSid = async (
-  callSid: string,
-): Promise<DeleteResult> => {
-  return getClientAudioBuffersCollection().deleteMany({ callSid });
-};
-
-const insertClientAudioBuffer = async (
-  audioBufferInput: CreateAudioBufferInput,
-): Promise<InsertOneResult<ClientAudioBufferType>> => {
-  const collection = getClientAudioBuffersCollection();
-  const realtimeDate = new Date();
-  const ttlMs = audioBufferInput.ttlMs ?? 3600_000;
-  const expiresAt = new Date(realtimeDate.getTime() + ttlMs);
-
-  const inputFieldsForDocument = {
-    callSid: audioBufferInput.callSid,
-    clientId: audioBufferInput.clientId,
-    bucketStartMs: audioBufferInput.bucketStartMs,
-    bucketDurationMs: audioBufferInput.bucketDurationMs,
-    data: audioBufferInput.data,
-  };
-  const clientAudioBufferMongoDocument: ClientAudioBufferType = {
-    ...inputFieldsForDocument,
-    codec: "mulaw",
-    sampleRateHz: 8000,
-    channels: 1,
-    createdAt: realtimeDate,
-    expiresAt: expiresAt,
-  };
-  return collection.insertOne(clientAudioBufferMongoDocument);
-};
-
-const findClientAudioBuffersByCallSidAndRange = async (
-  callSid: string,
-  startMs?: number,
-  endMs?: number,
-): Promise<ClientAudioBufferDoc[]> => {
-  const collection = getClientAudioBuffersCollection();
-  if (startMs === undefined) {
-    return collection.find({ callSid }).toArray();
-  }
-  const endMsToUse = endMs ?? Date.now();
-  return collection
-    .find({
-      callSid,
-      bucketStartMs: {
-        $gte: startMs,
-        $lte: endMsToUse,
-      },
-    })
-    .toArray();
-};
-
-const getAudioChunksByCallSid = async (
-  callSid: string,
-  limit?: number,
-): Promise<Buffer[]> => {
-  const query = getClientAudioBuffersCollection().find({ callSid });
-  if (limit) {
-    query.sort({ bucketStartMs: -1 }).limit(limit);
-  } else {
-    query.sort({ bucketStartMs: 1 });
-  }
-
-  const docs = await query.toArray();
-
-  if (!docs.length) {
-    return [];
-  }
-  const orderedDocs = limit ? docs.reverse() : docs;
-
-  return orderedDocs.map((chunk) => {
-    const data: any = chunk.data;
-    if (Buffer.isBuffer(data)) return data;
-    if (data?.buffer) return Buffer.from(data.buffer);
-    return Buffer.from(data);
-  });
-};
-
-const getMergedAudioByCallSid = async (
-  callSid: string,
-  limit: number,
-): Promise<Buffer> => {
-  const buffers = await getAudioChunksByCallSid(callSid, limit);
-
-  if (!buffers.length) {
-    return Buffer.alloc(0);
-  }
-
-  return Buffer.concat(buffers);
-};
-
-export {
-  insertClientAudioBuffer,
-  getClientAudioBuffersCollection,
-  findClientAudioBuffersByCallSidAndRange,
-  getAudioChunksByCallSid,
-  getMergedAudioByCallSid,
-  deleteAudioBuffersByCallSid,
-};
+import { getDb } from "../index";
+import {
+  ClientAudioBufferDoc,
+  ClientAudioBufferType,
+  CreateAudioBufferInput,
+} from "./clientsAudioBuffers.types";
+import { Collection, InsertOneResult, DeleteResult } from "mongodb";
+
+const getClientAudioBuffersCollection =
+  (): Collection<ClientAudioBufferType> => {
+    return getDb().collection<ClientAudioBufferType>("clientAudioBuffers");
+  };
+
+/**
+ * Deletes all audio buffers associated with a specific callSid.
+ * Useful for clearing context between different tickets in the same call.
+ */
+const deleteAudioBuffersByCallSid = async (
+  callSid: string,
+): Promise<DeleteResult> => {
+  return getClientAudioBuffersCollection().deleteMany({ callSid });
+};
+
+const insertClientAudioBuffer = async (
+  audioBufferInput: CreateAudioBufferInput,
+): Promise<InsertOneResult<ClientAudioBufferType>> => {
+  const collection = getClientAudioBuffersCollection();
+  const realtimeDate = new Date();
+  const ttlMs = audioBufferInput.ttlMs ?? 3600_000;
+  const expiresAt = new Date(realtimeDate.getTime() + ttlMs);
+
+  const inputFieldsForDocument = {
+    callSid: audioBufferInput.callSid,
+    clientId: audioBufferInput.clientId,
+    bucketStartMs: audioBufferInput.bucketStartMs,
+    bucketDurationMs: audioBufferInput.bucketDurationMs,
+    data: audioBufferInput.data,
+  };
+  const clientAudioBufferMongoDocument: ClientAudioBufferType = {
+    ...inputFieldsForDocument,
+    codec: "mulaw",
+    sampleRateHz: 8000,
+    channels: 1,
+    createdAt: realtimeDate,
+    expiresAt: expiresAt,
+  };
+  return collection.insertOne(clientAudioBufferMongoDocument);
+};
+
+const findClientAudioBuffersByCallSidAndRange = async (
+  callSid: string,
+  startMs?: number,
+  endMs?: number,
+): Promise<ClientAudioBufferDoc[]> => {
+  const collection = getClientAudioBuffersCollection();
+  if (startMs === undefined) {
+    return collection.find({ callSid }).toArray();
+  }
+  const endMsToUse = endMs ?? Date.now();
+  return collection
+    .find({
+      callSid,
+      bucketStartMs: {
+        $gte: startMs,
+        $lte: endMsToUse,
+      },
+    })
+    .toArray();
+};
+
+const getAudioChunksByCallSid = async (
+  callSid: string,
+  limit?: number,
+): Promise<Buffer[]> => {
+  const query = getClientAudioBuffersCollection().find({ callSid });
+  if (limit) {
+    query.sort({ bucketStartMs: -1 }).limit(limit);
+  } else {
+    query.sort({ bucketStartMs: 1 });
+  }
+
+  const docs = await query.toArray();
+
+  if (!docs.length) {
+    return [];
+  }
+  const orderedDocs = limit ? docs.reverse() : docs;
+
+  return orderedDocs.map((chunk) => {
+    const data: any = chunk.data;
+    if (Buffer.isBuffer(data)) return data;
+    if (data?.buffer) return Buffer.from(data.buffer);
+    return Buffer.from(data);
+  });
+};
+
+const getMergedAudioByCallSid = async (
+  callSid: string,
+  limit: number,
+): Promise<Buffer> => {
+  const buffers = await getAudioChunksByCallSid(callSid, limit);
+
+  if (!buffers.length) {
+    return Buffer.alloc(0);
+  }
+
+  return Buffer.concat(buffers);
+};
+
+export {
+  insertClientAudioBuffer,
+  getClientAudioBuffersCollection,
+  findClientAudioBuffersByCallSidAndRange,
+  getAudioChunksByCallSid,
+  getMergedAudioByCallSid,
+  deleteAudioBuffersByCallSid,
+};

package/src/talkpilot/clientAudioBuffers/clientsAudioBuffers.types.ts

@@ -1,25 +1,25 @@
-import { WithId } from "mongodb";
-
-export type ClientAudioBufferType = {
-  callSid: string;
-  clientId: string;
-  bucketStartMs: number;
-  bucketDurationMs: number;
-  codec: "mulaw";
-  sampleRateHz: 8000;
-  channels: 1;
-  data: Buffer;
-  expiresAt: Date;
-  createdAt: Date;
-};
-
-export type CreateAudioBufferInput = {
-  callSid: string;
-  clientId: string;
-  bucketStartMs: number;
-  bucketDurationMs: number;
-  data: Buffer;
-  ttlMs?: number;
-};
-
-export type ClientAudioBufferDoc = WithId<ClientAudioBufferType>;
+import { WithId } from "mongodb";
+
+export type ClientAudioBufferType = {
+  callSid: string;
+  clientId: string;
+  bucketStartMs: number;
+  bucketDurationMs: number;
+  codec: "mulaw";
+  sampleRateHz: 8000;
+  channels: 1;
+  data: Buffer;
+  expiresAt: Date;
+  createdAt: Date;
+};
+
+export type CreateAudioBufferInput = {
+  callSid: string;
+  clientId: string;
+  bucketStartMs: number;
+  bucketDurationMs: number;
+  data: Buffer;
+  ttlMs?: number;
+};
+
+export type ClientAudioBufferDoc = WithId<ClientAudioBufferType>;

package/src/talkpilot/clientAudioBuffers/index.ts

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

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

@@ -0,0 +1,33 @@
+import { getClientsCollection, getAllClientCredits } from "../clients.getters";
+import { createClient } from "../../../test-utils/factories";
+
+describe("db.clients", () => {
+  describe("getAllClientCredits", () => {
+    it("should return a Map of clientId to credits across all clients", async () => {
+      await getClientsCollection().insertMany([
+        createClient({ clientId: "creditsClientA", credits: 100 }),
+        createClient({ clientId: "creditsClientB", credits: 250 }),
+      ]);
+
+      const result = await getAllClientCredits();
+
+      expect(result).toBeInstanceOf(Map);
+      expect(result.get("creditsClientA")).toBe(100);
+      expect(result.get("creditsClientB")).toBe(250);
+    });
+
+    it("should default missing credits to 0", async () => {
+      const client = createClient({ clientId: "noCreditsClient" });
+      delete (client as { credits?: number }).credits;
+      await getClientsCollection().insertOne(client);
+
+      const result = await getAllClientCredits();
+      expect(result.get("noCreditsClient")).toBe(0);
+    });
+
+    it("should return an empty Map when there are no clients", async () => {
+      const result = await getAllClientCredits();
+      expect(result.size).toBe(0);
+    });
+  });
+});

package/src/talkpilot/clients/__tests__/clients.lifecycle.spec.ts

@@ -0,0 +1,166 @@
+import {
+  clientExistsInAnyCollection,
+  deleteClientDataAcrossDomains,
+} from "../clients.lifecycle";
+import { getPhoneNumbersCollection } from "../../phone_numbers/phone_numbers.getter";
+import {
+  createMuniIssue,
+  generateMuniIssueId,
+  getAuditLogsCollection,
+  getScansCollection,
+} from "../../../index";
+import {
+  createPhoneNumber,
+  createMuniIssueInput,
+  createScanFixture,
+} from "../../../test-utils/factories";
+
+describe("db.clients.lifecycle", () => {
+  describe("clientExistsInAnyCollection", () => {
+    it("should return true when the client exists only in phone_numbers (client_id field)", async () => {
+      const clientId = "existsPhoneOnly";
+      await getPhoneNumbersCollection().insertOne(
+        createPhoneNumber({ client_id: clientId }),
+      );
+
+      expect(await clientExistsInAnyCollection(clientId)).toBe(true);
+    });
+
+    it("should return true when the client exists only in muniIssues (municipal DB)", async () => {
+      const clientId = "existsMuniOnly";
+      await createMuniIssue(
+        createMuniIssueInput({ clientId }),
+        generateMuniIssueId(),
+      );
+
+      expect(await clientExistsInAnyCollection(clientId)).toBe(true);
+    });
+
+    it("should return false when the client does not exist anywhere", async () => {
+      expect(await clientExistsInAnyCollection("noSuchClientAtAll")).toBe(
+        false,
+      );
+    });
+
+    it("should not consider websitalk data (scans/websiteUrls) at all", async () => {
+      const clientId = "onlyInWebsitalk";
+      await getScansCollection().insertOne(createScanFixture({ clientId }));
+
+      expect(await clientExistsInAnyCollection(clientId)).toBe(false);
+    });
+
+    it("should not be fooled by unrelated collections lacking a clientId/client_id field", async () => {
+      await global.db
+        .collection("someUnrelatedCollection")
+        .insertOne({ someField: "someValue" });
+
+      expect(await clientExistsInAnyCollection("noSuchClientAtAll")).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("deleteClientDataAcrossDomains", () => {
+    it("should return deleted:false with a reason and delete nothing when the client does not exist", async () => {
+      await getPhoneNumbersCollection().insertOne(
+        createPhoneNumber({ client_id: "unrelatedClient" }),
+      );
+
+      const summary = await deleteClientDataAcrossDomains(
+        "missingClient",
+        "admin@callai.co.il",
+      );
+
+      expect(summary.deleted).toBe(false);
+      if (!summary.deleted) {
+        expect(summary.reason).toBeTruthy();
+      }
+      expect(
+        await getPhoneNumbersCollection().findOne({
+          client_id: "unrelatedClient",
+        }),
+      ).not.toBeNull();
+    });
+
+    it("should not write an audit log entry when the client does not exist", async () => {
+      await deleteClientDataAcrossDomains(
+        "missingClientNoAudit",
+        "admin@callai.co.il",
+      );
+
+      expect(
+        await getAuditLogsCollection().findOne({
+          clientId: "missingClientNoAudit",
+        }),
+      ).toBeNull();
+    });
+
+    it("should delete the client's data across talkpilot and municipal domains", async () => {
+      const clientId = "deleteMeEverywhere";
+      await getPhoneNumbersCollection().insertOne(
+        createPhoneNumber({ client_id: clientId }),
+      );
+      await createMuniIssue(
+        createMuniIssueInput({ clientId }),
+        generateMuniIssueId(),
+      );
+
+      const adminEmail = "admin@callai.co.il";
+      const summary = await deleteClientDataAcrossDomains(
+        clientId,
+        adminEmail,
+      );
+
+      expect(summary.deleted).toBe(true);
+      if (summary.deleted) {
+        expect(summary.allSucceeded).toBe(true);
+        const byName = (name: string) =>
+          summary.results.find((r) => r.collectionName === name);
+        expect(byName("phone_numbers")?.deletedCount).toBe(1);
+        expect(byName("muniIssues")?.deletedCount).toBe(1);
+      }
+
+      expect(await clientExistsInAnyCollection(clientId)).toBe(false);
+
+      // The audit entry itself must survive the client's own deletion.
+      const auditEntry = await getAuditLogsCollection().findOne({ clientId });
+      expect(auditEntry).toMatchObject({
+        clientId,
+        adminEmail,
+        action: "delete",
+      });
+      expect(auditEntry?.timestamp).toBeInstanceOf(Date);
+    });
+
+    it("should not touch websitalk data (scans/websiteUrls) — callers must call the external website-talk deletion API separately", async () => {
+      const clientId = "hasWebsitalkData";
+      await getPhoneNumbersCollection().insertOne(
+        createPhoneNumber({ client_id: clientId }),
+      );
+      await getScansCollection().insertOne(createScanFixture({ clientId }));
+
+      await deleteClientDataAcrossDomains(clientId, "admin@callai.co.il");
+
+      expect(
+        await getScansCollection().findOne({ clientId }),
+      ).not.toBeNull();
+    });
+
+    it("should not delete unrelated clients' data", async () => {
+      const targetClient = "deleteTarget";
+      const otherClient = "keepMeClient";
+      await getPhoneNumbersCollection().insertOne(
+        createPhoneNumber({ client_id: targetClient }),
+      );
+      await getPhoneNumbersCollection().insertOne(
+        createPhoneNumber({ client_id: otherClient }),
+      );
+
+      await deleteClientDataAcrossDomains(targetClient, "admin@callai.co.il");
+
+      expect(
+        await getPhoneNumbersCollection().findOne({ client_id: otherClient }),
+      ).not.toBeNull();
+    });
+  });
+});