@talkpilot/core-db 1.3.66 → 1.3.68

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

@@ -1,374 +0,0 @@
-import { ObjectId } from "mongodb";
-import {
-  aggregateActiveCallsSummary,
-  aggregateTodayCallsSummary,
-  aggregateClientCallStats,
-  aggregateSessionCallStats,
-  getAllClientsLastCallDate,
-  findClientIdsByCallSids,
-  getCallsCollection,
-} from "../calls.getters";
-import { getSessionsCollection } from "../../sessions/sessions.getter";
-import type { Call } from "../calls.types";
-import {
-  createOutGoingCallDoc,
-  createIncomingCallDoc,
-  createSession,
-} from "../../../test-utils/factories";
-
-const insertCall = (call: Call) =>
-  getCallsCollection().insertOne({ ...call, env: call.env ?? "test" });
-
-describe("calls.getters statistics", () => {
-  describe("aggregateActiveCallsSummary", () => {
-    it("should count distinct active calls within the last 2 hours, split incoming/outgoing", async () => {
-      const now = new Date();
-      await Promise.all([
-        insertCall(createIncomingCallDoc({ clientId: "clientA", status: "in-progress", updatedAt: now })),
-        insertCall(createOutGoingCallDoc({ clientId: "clientB", status: "in-progress", updatedAt: now })),
-        insertCall(createIncomingCallDoc({ clientId: "clientC", status: "completed", updatedAt: now })),
-      ]);
-
-      const summary = await aggregateActiveCallsSummary();
-
-      expect(summary.total).toBe(2);
-      expect(summary.incoming).toBe(1);
-      expect(summary.outgoing).toBe(1);
-      expect(summary.activeClientIds.sort()).toEqual(["clientA", "clientB"]);
-    });
-
-    it("should filter by clientId when provided", async () => {
-      const now = new Date();
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "onlyThisClient", status: "in-progress", updatedAt: now })),
-        insertCall(createOutGoingCallDoc({ clientId: "otherClient", status: "in-progress", updatedAt: now })),
-      ]);
-
-      const summary = await aggregateActiveCallsSummary("onlyThisClient");
-      expect(summary.total).toBe(1);
-      expect(summary.activeClientIds).toEqual(["onlyThisClient"]);
-    });
-
-    it("should exclude calls whose updatedAt is older than 2 hours", async () => {
-      const threeHoursAgo = new Date(Date.now() - 3 * 60 * 60 * 1000);
-      await insertCall(createOutGoingCallDoc({ status: "in-progress", updatedAt: threeHoursAgo }));
-
-      const summary = await aggregateActiveCallsSummary();
-      expect(summary.total).toBe(0);
-    });
-  });
-
-  describe("aggregateTodayCallsSummary", () => {
-    it("should aggregate status/type counts and total minutes within the given date range", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      await Promise.all([
-        insertCall(createIncomingCallDoc({ status: "completed", callLength: 120, createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ status: "failed", callLength: 30, createdAt: new Date() })),
-      ]);
-
-      const summary = await aggregateTodayCallsSummary({ dateFrom: today, dateTo: today });
-
-      expect(summary.total).toBe(2);
-      expect(summary.incoming).toBe(1);
-      expect(summary.outgoing).toBe(1);
-      expect(summary.completed).toBe(1);
-      expect(summary.failed).toBe(1);
-      expect(summary.totalMinutes).toBe(3); // ceil(150/60)
-    });
-
-    it("should respect the given timezone when resolving an explicit date", async () => {
-      // 23:30 UTC on 2026-01-01 is already 2026-01-02 in Asia/Jerusalem (+2).
-      const lateUtc = new Date("2026-01-01T23:30:00.000Z");
-      await insertCall(createOutGoingCallDoc({ status: "completed", createdAt: lateUtc }));
-
-      const summaryUtc = await aggregateTodayCallsSummary({
-        dateFrom: "2026-01-01",
-        dateTo: "2026-01-01",
-        timezone: "UTC",
-      });
-      expect(summaryUtc.total).toBe(1);
-
-      const summaryJerusalem = await aggregateTodayCallsSummary({
-        dateFrom: "2026-01-01",
-        dateTo: "2026-01-01",
-        timezone: "Asia/Jerusalem",
-      });
-      expect(summaryJerusalem.total).toBe(0);
-    });
-
-    it("should include a call's full history (not just today) when no date range is given", async () => {
-      const sixMonthsAgo = new Date(Date.now() - 180 * 24 * 60 * 60 * 1000);
-      await insertCall(createOutGoingCallDoc({ status: "completed", createdAt: sixMonthsAgo }));
-
-      const summary = await aggregateTodayCallsSummary({});
-      expect(summary.total).toBe(1);
-    });
-  });
-
-  describe("aggregateClientCallStats", () => {
-    it("should group call counts and minutes by clientId", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      await Promise.all([
-        insertCall(
-          createOutGoingCallDoc({ clientId: "clientX", status: "completed", callLength: 60, createdAt: new Date() }),
-        ),
-        insertCall(
-          createOutGoingCallDoc({ clientId: "clientX", status: "failed", callLength: 60, createdAt: new Date() }),
-        ),
-      ]);
-
-      const rows = await aggregateClientCallStats({ dateFrom: today, dateTo: today });
-      const row = rows.find((r) => r.clientId === "clientX");
-
-      expect(row?.totalCalls).toBe(2);
-      expect(row?.statusCounts).toMatchObject({ completed: 1, failed: 1 });
-      expect(row?.totalMinutes).toBe(2);
-    });
-
-    it("should not include other clients when filtered by clientId", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "wantedClient", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "unwantedClient", status: "completed", createdAt: new Date() })),
-      ]);
-
-      const rows = await aggregateClientCallStats({
-        dateFrom: today,
-        dateTo: today,
-        clientId: "wantedClient",
-      });
-
-      expect(rows).toHaveLength(1);
-      expect(rows[0].clientId).toBe("wantedClient");
-    });
-
-    it("should include a client's full history when no date range is given", async () => {
-      const sixMonthsAgo = new Date(Date.now() - 180 * 24 * 60 * 60 * 1000);
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "longHistoryClient", status: "completed", createdAt: sixMonthsAgo })),
-        insertCall(createOutGoingCallDoc({ clientId: "longHistoryClient", status: "completed", createdAt: new Date() })),
-      ]);
-
-      const rows = await aggregateClientCallStats({});
-      const row = rows.find((r) => r.clientId === "longHistoryClient");
-
-      expect(row?.totalCalls).toBe(2);
-    });
-
-    it("should set lastCallDate to the most recent call", async () => {
-      const earlierCall = new Date("2026-01-01T00:00:00.000Z");
-      const laterCall = new Date("2026-03-10T00:00:00.000Z");
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "lastCallDateClient", status: "completed", createdAt: earlierCall })),
-        insertCall(createOutGoingCallDoc({ clientId: "lastCallDateClient", status: "completed", createdAt: laterCall })),
-      ]);
-
-      const rows = await aggregateClientCallStats({});
-      const row = rows.find((r) => r.clientId === "lastCallDateClient");
-
-      expect(row?.lastCallDate).toEqual(laterCall);
-    });
-
-    it("should filter by clientId alone when no date range is given", async () => {
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "onlyThisClientNoRange", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "otherClientNoRange", status: "completed", createdAt: new Date() })),
-      ]);
-
-      const rows = await aggregateClientCallStats({ clientId: "onlyThisClientNoRange" });
-
-      expect(rows).toHaveLength(1);
-      expect(rows[0].clientId).toBe("onlyThisClientNoRange");
-    });
-
-    it("should count every real status separately, including queued; a missing status only inflates totalCalls", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "canceled", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "queued" as any, createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "ringing", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "initiated", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "answered", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: undefined, createdAt: new Date() })),
-      ]);
-
-      const rows = await aggregateClientCallStats({ dateFrom: today, dateTo: today });
-      const row = rows.find((r) => r.clientId === "statusBucketClient");
-
-      expect(row?.totalCalls).toBe(7);
-      expect(row?.statusCounts).toMatchObject({
-        completed: 1,
-        canceled: 1,
-        queued: 1,
-        ringing: 1,
-        initiated: 1,
-        answered: 1,
-      });
-    });
-  });
-
-  describe("aggregateSessionCallStats", () => {
-    it("should group by sessionId and resolve the session's current name via the sessions collection", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const sessionId = new ObjectId();
-      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "My Session" }));
-      await insertCall(
-        createOutGoingCallDoc({ sessionId, status: "completed", createdAt: new Date() }),
-      );
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-      const row = rows.find((r) => r.sessionId === sessionId.toString());
-
-      expect(row).toMatchObject({ sessionName: "My Session", totalCalls: 1 });
-      expect(row?.statusCounts).toMatchObject({ completed: 1 });
-    });
-
-    it("should always show the session's current name, even if it was renamed after some calls happened", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const sessionId = new ObjectId();
-      const earlierCall = new Date(Date.now() - 60 * 60 * 1000);
-      const laterCall = new Date();
-
-      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "New Name" }));
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: earlierCall })),
-        insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: laterCall })),
-      ]);
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-      const merged = rows.find((r) => r.sessionId === sessionId.toString());
-
-      expect(merged).toMatchObject({ sessionName: "New Name", totalCalls: 2 });
-      expect(merged?.statusCounts).toMatchObject({ completed: 2 });
-    });
-
-    it("should show 'Unknown' when the session no longer exists in the sessions collection", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const orphanedSessionId = new ObjectId();
-      await insertCall(createOutGoingCallDoc({ sessionId: orphanedSessionId, status: "completed", createdAt: new Date() }));
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-      const row = rows.find((r) => r.sessionId === orphanedSessionId.toString());
-
-      expect(row?.sessionName).toBe("Unknown");
-    });
-
-    it("should label a null sessionId as 'Incoming Call', not 'Unknown' — a call with no session is expected, not broken data", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      await Promise.all([
-        insertCall(createIncomingCallDoc({ status: "completed", createdAt: new Date() })),
-        insertCall(createIncomingCallDoc({ status: "failed", createdAt: new Date() })),
-      ]);
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-      const row = rows.find((r) => r.sessionName === "Incoming Call");
-
-      expect(row).toBeDefined();
-      expect(row?.totalCalls).toBe(2);
-      expect(row?.statusCounts).toMatchObject({ completed: 1, failed: 1 });
-      expect(row?.sessionName).not.toBe("Unknown");
-    });
-
-    it("should only include the given client's sessions when clientId is provided", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const sessionA = new ObjectId();
-      const sessionB = new ObjectId();
-      await getSessionsCollection().insertMany([
-        createSession({ _id: sessionA, session_name: "Session A" }),
-        createSession({ _id: sessionB, session_name: "Session B" }),
-      ]);
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "clientA", sessionId: sessionA, status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "clientB", sessionId: sessionB, status: "completed", createdAt: new Date() })),
-      ]);
-
-      const rows = await aggregateSessionCallStats({
-        dateFrom: today,
-        dateTo: today,
-        clientId: "clientA",
-      });
-
-      expect(rows).toHaveLength(1);
-      expect(rows[0]).toMatchObject({ sessionId: sessionA.toString(), sessionName: "Session A" });
-    });
-
-    it("should exclude a session with no calls in the given date range", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const longAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
-      const oldSessionId = new ObjectId();
-      await getSessionsCollection().insertOne(createSession({ _id: oldSessionId, session_name: "Old Session" }));
-      await insertCall(createOutGoingCallDoc({ sessionId: oldSessionId, status: "completed", createdAt: longAgo }));
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-
-      expect(rows.find((r) => r.sessionId === oldSessionId.toString())).toBeUndefined();
-    });
-
-    it("should include a session's full history when no date range is given", async () => {
-      const longAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
-      const sessionId = new ObjectId();
-      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "All Time Session" }));
-      await insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: longAgo }));
-
-      const rows = await aggregateSessionCallStats({});
-      const row = rows.find((r) => r.sessionId === sessionId.toString());
-
-      expect(row?.totalCalls).toBe(1);
-    });
-
-    it("should count each real status separately, including queued", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const sessionId = new ObjectId();
-      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "Bucket Session" }));
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ sessionId, status: "canceled", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ sessionId, status: "queued" as any, createdAt: new Date() })),
-      ]);
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-      const row = rows.find((r) => r.sessionId === sessionId.toString());
-
-      expect(row?.totalCalls).toBe(3);
-      expect(row?.statusCounts).toMatchObject({ completed: 1, canceled: 1, queued: 1 });
-    });
-  });
-
-  describe("getAllClientsLastCallDate", () => {
-    it("should map each clientId to its most recent call, ignoring any date range", async () => {
-      const earlierCall = new Date("2026-01-01T00:00:00.000Z");
-      const laterCall = new Date("2026-03-10T00:00:00.000Z");
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "lastCallMapClientA", status: "completed", createdAt: earlierCall })),
-        insertCall(createOutGoingCallDoc({ clientId: "lastCallMapClientA", status: "completed", createdAt: laterCall })),
-        insertCall(createOutGoingCallDoc({ clientId: "lastCallMapClientB", status: "completed", createdAt: earlierCall })),
-      ]);
-
-      const map = await getAllClientsLastCallDate();
-
-      expect(map.get("lastCallMapClientA")).toEqual(laterCall);
-      expect(map.get("lastCallMapClientB")).toEqual(earlierCall);
-    });
-  });
-
-  describe("findClientIdsByCallSids", () => {
-    it("should map each callSid to the clientId that owns it", async () => {
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "clientA", callSid: "CAaaa" })),
-        insertCall(createOutGoingCallDoc({ clientId: "clientB", callSid: "CAbbb" })),
-      ]);
-
-      const map = await findClientIdsByCallSids(["CAaaa", "CAbbb", "CAunknown"]);
-
-      expect(map.get("CAaaa")).toBe("clientA");
-      expect(map.get("CAbbb")).toBe("clientB");
-      expect(map.has("CAunknown")).toBe(false);
-    });
-
-    it("should return an empty map when given no callSids", async () => {
-      const map = await findClientIdsByCallSids([]);
-      expect(map.size).toBe(0);
-    });
-  });
-});

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

@@ -1,51 +0,0 @@
-import { getClientsCollection, getAllClientCredits, getAllClientIds } 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);
-    });
-  });
-
-  describe("getAllClientIds", () => {
-    it("should return the ids of all clients", async () => {
-      await getClientsCollection().insertMany([
-        createClient({ clientId: "idClientA" }),
-        createClient({ clientId: "idClientB" }),
-      ]);
-
-      const result = await getAllClientIds();
-
-      expect(result.sort()).toEqual(["idClientA", "idClientB"]);
-    });
-
-    it("should return an empty array when there are no clients", async () => {
-      const result = await getAllClientIds();
-      expect(result).toEqual([]);
-    });
-  });
-});

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

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

package/src/talkpilot/clients/clients.constants.ts

@@ -1,2 +0,0 @@
-/** Collections to always skip during client deletion — e.g. auditLogs, which must survive it. */
-export const DELETE_DENYLIST: string[] = ["auditLogs"];