@talkpilot/core-db 1.3.89 → 1.3.90

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

@@ -1,224 +0,0 @@
-import {
-  getClientsCollection,
-  getAllClientIds,
-  getBackofficeRole,
-  setBackofficeRole,
-  countBackofficeAdmins,
-  findClientsPage,
-} from "../clients.getters";
-import { getPhoneNumbersCollection } from "../../phone_numbers/phone_numbers.getter";
-import { createClient, createPhoneNumber } from "../../../test-utils/factories";
-
-describe("db.clients", () => {
-  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([]);
-    });
-  });
-
-  describe("getBackofficeRole", () => {
-    it("returns 'admin' when backoffice.admin is set", async () => {
-      await getClientsCollection().insertOne(
-        createClient({
-          clientId: "roleAdmin",
-          roles: { backoffice: { admin: true } },
-        }),
-      );
-      expect(await getBackofficeRole("roleAdmin")).toBe("admin");
-    });
-
-    it("returns 'viewer' when only backoffice.viewer is set", async () => {
-      await getClientsCollection().insertOne(
-        createClient({
-          clientId: "roleViewer",
-          roles: { backoffice: { viewer: true } },
-        }),
-      );
-      expect(await getBackofficeRole("roleViewer")).toBe("viewer");
-    });
-
-    it("lets admin win when both flags are set", async () => {
-      await getClientsCollection().insertOne(
-        createClient({
-          clientId: "roleBoth",
-          roles: { backoffice: { admin: true, viewer: true } },
-        }),
-      );
-      expect(await getBackofficeRole("roleBoth")).toBe("admin");
-    });
-
-    it("ignores the legacy roles.admin flag", async () => {
-      await getClientsCollection().insertOne(
-        createClient({ clientId: "legacyAdmin", roles: { admin: true } }),
-      );
-      expect(await getBackofficeRole("legacyAdmin")).toBeNull();
-    });
-
-    it("returns null for false flags, a client without roles, and an unknown client", async () => {
-      await getClientsCollection().insertMany([
-        createClient({
-          clientId: "roleFalse",
-          roles: { backoffice: { admin: false, viewer: false } },
-        }),
-        createClient({ clientId: "noRoles" }),
-      ]);
-      expect(await getBackofficeRole("roleFalse")).toBeNull();
-      expect(await getBackofficeRole("noRoles")).toBeNull();
-      expect(await getBackofficeRole("missing")).toBeNull();
-    });
-  });
-
-  describe("setBackofficeRole", () => {
-    it("sets one role, clears the other, and leaves roles.admin alone", async () => {
-      await getClientsCollection().insertOne(
-        createClient({
-          clientId: "switchRole",
-          roles: { admin: true, backoffice: { admin: true } },
-        }),
-      );
-
-      expect(await setBackofficeRole("switchRole", "viewer")).toBe(true);
-      expect(await getBackofficeRole("switchRole")).toBe("viewer");
-
-      await setBackofficeRole("switchRole", null);
-      expect(await getBackofficeRole("switchRole")).toBeNull();
-
-      const doc = await getClientsCollection().findOne({
-        clientId: "switchRole",
-      });
-      expect(doc?.roles?.admin).toBe(true);
-    });
-
-    it("returns false for an unknown client", async () => {
-      expect(await setBackofficeRole("missing", "admin")).toBe(false);
-    });
-  });
-
-  describe("countBackofficeAdmins", () => {
-    it("counts only clients with the backoffice admin flag", async () => {
-      await getClientsCollection().insertMany([
-        createClient({
-          clientId: "adminOne",
-          roles: { backoffice: { admin: true } },
-        }),
-        createClient({
-          clientId: "viewerOne",
-          roles: { backoffice: { viewer: true } },
-        }),
-        createClient({ clientId: "legacyOnly", roles: { admin: true } }),
-      ]);
-      expect(await countBackofficeAdmins()).toBe(1);
-    });
-  });
-
-  describe("findClientsPage", () => {
-    const insertClientsCreatedAt = (...clientIds: string[]) =>
-      getClientsCollection().insertMany(
-        clientIds.map((clientId, index) =>
-          createClient({
-            clientId,
-            createdAt: new Date(Date.UTC(2026, 0, index + 1)),
-          }),
-        ),
-      );
-
-    it("returns one page, newest client first, with the total across all pages", async () => {
-      await insertClientsCreatedAt("pageOldest", "pageMiddle", "pageNewest");
-
-      const firstPage = await findClientsPage({ skip: 0, limit: 2 });
-      const secondPage = await findClientsPage({ skip: 2, limit: 2 });
-
-      expect(firstPage.clients.map((c) => c.clientId)).toEqual([
-        "pageNewest",
-        "pageMiddle",
-      ]);
-      expect(firstPage.total).toBe(3);
-      expect(secondPage.clients.map((c) => c.clientId)).toEqual(["pageOldest"]);
-      expect(secondPage.total).toBe(3);
-    });
-
-    it("searches the clientId case-insensitively", async () => {
-      await insertClientsCreatedAt("SearchMe-1", "other-client");
-
-      const page = await findClientsPage({
-        skip: 0,
-        limit: 10,
-        search: "searchme",
-      });
-
-      expect(page.clients.map((c) => c.clientId)).toEqual(["SearchMe-1"]);
-      expect(page.total).toBe(1);
-    });
-
-    it("searches phone numbers, treating regex characters like + as plain text", async () => {
-      await insertClientsCreatedAt("phoneOwner", "noPhoneMatch");
-      await getPhoneNumbersCollection().insertMany([
-        createPhoneNumber({
-          client_id: "phoneOwner",
-          phone_number: "+97233823446",
-        }),
-        createPhoneNumber({
-          client_id: "noPhoneMatch",
-          phone_number: "+97250000000",
-        }),
-      ]);
-
-      const page = await findClientsPage({
-        skip: 0,
-        limit: 10,
-        search: "+9723382",
-      });
-
-      expect(page.clients.map((c) => c.clientId)).toEqual(["phoneOwner"]);
-    });
-
-    it("filters to one exact clientId", async () => {
-      await insertClientsCreatedAt("exactClient", "exactClient-2");
-
-      const page = await findClientsPage({
-        skip: 0,
-        limit: 10,
-        clientId: "exactClient",
-      });
-
-      expect(page.clients.map((c) => c.clientId)).toEqual(["exactClient"]);
-    });
-
-    it("restricts to clientIds and leaves out excludeClientIds", async () => {
-      await insertClientsCreatedAt("listA", "listB", "listC");
-
-      const included = await findClientsPage({
-        skip: 0,
-        limit: 10,
-        clientIds: ["listA", "listC"],
-      });
-      const excluded = await findClientsPage({
-        skip: 0,
-        limit: 10,
-        excludeClientIds: ["listA"],
-      });
-
-      expect(included.clients.map((c) => c.clientId)).toEqual([
-        "listC",
-        "listA",
-      ]);
-      expect(excluded.clients.map((c) => c.clientId)).toEqual([
-        "listC",
-        "listB",
-      ]);
-      expect(excluded.total).toBe(2);
-    });
-  });
-});

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

@@ -1,194 +0,0 @@
-import {
-  clientExistsInAnyCollection,
-  deleteClientDataAcrossDomains,
-} from "../clients.lifecycle";
-import { getPhoneNumbersCollection } from "../../phone_numbers/phone_numbers.getter";
-import * as auditLogsGetters from "../../auditLogs/auditLogs.getters";
-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);
-        expect(summary.auditLogged).toBe(true);
-        expect(summary.auditError).toBeUndefined();
-        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 still delete the data and report auditLogged: false when the audit write fails", async () => {
-      const clientId = "auditWriteFails";
-      await getPhoneNumbersCollection().insertOne(
-        createPhoneNumber({ client_id: clientId }),
-      );
-      const insertAuditLog = jest
-        .spyOn(auditLogsGetters, "insertAuditLog")
-        .mockRejectedValueOnce(new Error("audit write failed"));
-
-      const summary = await deleteClientDataAcrossDomains(
-        clientId,
-        "admin@callai.co.il",
-      );
-
-      expect(summary).toMatchObject({
-        deleted: true,
-        allSucceeded: true,
-        auditLogged: false,
-        auditError: "audit write failed",
-      });
-      expect(await clientExistsInAnyCollection(clientId)).toBe(false);
-
-      insertAuditLog.mockRestore();
-    });
-
-    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,4 +0,0 @@
-/** Collections to always skip during client deletion — e.g. auditLogs, which must survive it. */
-export const DELETE_DENYLIST: string[] = ["auditLogs"];
-
-export const BACKOFFICE_ROLES = ["admin", "viewer"] as const;

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

@@ -1,132 +0,0 @@
-import { Db } from "mongodb";
-import { getDb, insertAuditLog } from "../index";
-import type { AuditLogEntry } from "../auditLogs/auditLogs.types";
-import { getDb as getMunicipalDataDb } from "../../municipal";
-import { DELETE_DENYLIST } from "./clients.constants";
-import {
-  AuditLogResult,
-  CollectionMatch,
-  CollectionDeleteResult,
-  DeleteClientDataSummary,
-} from "./clients.types";
-
-// Skips websitalk on purpose — see the warning on `deleteClientDataAcrossDomains` below.
-const findClientMatchInDb = async (
-  db: Db,
-  clientId: string,
-): Promise<CollectionMatch[]> => {
-  const collections = await db.listCollections().toArray();
-  return Promise.all(
-    collections
-      .filter((c) => !DELETE_DENYLIST.includes(c.name))
-      .map(async (c) => {
-        const doc = await db
-          .collection(c.name)
-          .findOne({ $or: [{ clientId }, { client_id: clientId }] });
-        return { collectionName: c.name, matched: !!doc };
-      }),
-  );
-};
-
-export const clientExistsInAnyCollection = async (
-  clientId: string,
-): Promise<boolean> => {
-  const [talkpilotResults, municipalResults] = await Promise.all([
-    findClientMatchInDb(getDb(), clientId),
-    findClientMatchInDb(getMunicipalDataDb(), clientId),
-  ]);
-  return [...talkpilotResults, ...municipalResults].some((r) => r.matched);
-};
-
-const deleteClientFromDb = async (
-  db: Db,
-  clientId: string,
-): Promise<CollectionDeleteResult[]> => {
-  const collections = await db.listCollections().toArray();
-  return Promise.all(
-    collections
-      .filter((c) => !DELETE_DENYLIST.includes(c.name))
-      .map(async (c) => {
-        try {
-          const result = await db
-            .collection(c.name)
-            .deleteMany({ $or: [{ clientId }, { client_id: clientId }] });
-          return {
-            collectionName: c.name,
-            deletedCount: result.deletedCount,
-            success: true,
-          };
-        } catch (error) {
-          return {
-            collectionName: c.name,
-            deletedCount: 0,
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-          };
-        }
-      }),
-  );
-};
-
-// The data is already deleted at this point — a failed audit write must not abort the caller.
-const tryInsertAuditLog = async (entry: AuditLogEntry): Promise<AuditLogResult> => {
-  try {
-    await insertAuditLog(entry);
-    return { auditLogged: true };
-  } catch (error) {
-    return {
-      auditLogged: false,
-      auditError: error instanceof Error ? error.message : String(error),
-    };
-  }
-};
-
-/**
- * Deletes a client's data across talkpilot/municipal collections and logs the action.
- *
- * ⚠️ Does NOT delete website-talk data — `scans`/`websiteUrls` are the lookup key an
- * external API needs to clean up that domain. Callers must invoke that API separately.
- */
-export const deleteClientDataAcrossDomains = async (
-  clientId: string,
-  adminEmail: string,
-): Promise<DeleteClientDataSummary> => {
-  const exists = await clientExistsInAnyCollection(clientId);
-  if (!exists) {
-    return {
-      clientId,
-      deleted: false,
-      reason: "Client does not exist in any collection",
-    };
-  }
-
-  const [talkpilotResults, municipalResults] = await Promise.all([
-    deleteClientFromDb(getDb(), clientId),
-    deleteClientFromDb(getMunicipalDataDb(), clientId),
-  ]);
-  const results = [...talkpilotResults, ...municipalResults];
-  const allSucceeded = results.every((r) => r.success);
-
-  const auditResult = await tryInsertAuditLog({
-    clientId,
-    adminEmail,
-    action: "delete",
-    timestamp: new Date(),
-    allSucceeded,
-    ...(allSucceeded
-      ? {}
-      : {
-          failedCollections: results
-            .filter((r) => !r.success)
-            .map((r) => r.collectionName),
-        }),
-  });
-
-  return {
-    clientId,
-    deleted: true,
-    results,
-    allSucceeded,
-    ...auditResult,
-  };
-};

package/src/test-utils/factories/talkpilot/clients.ts

@@ -1,21 +0,0 @@
-import { Factory } from "fishery";
-import { ObjectId } from "mongodb";
-import { faker } from "@faker-js/faker";
-import type { Client } from "../../../talkpilot";
-
-export const clientFactory = Factory.define<Client & { _id?: ObjectId }>(
-  () => ({
-    _id: new ObjectId(),
-    clientId: faker.string.uuid(),
-    isActive: true,
-    credits: faker.number.int({ min: 0, max: 1000 }),
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  }),
-);
-
-export function createClient(
-  overrides?: Partial<Client>,
-): Client & { _id?: ObjectId } {
-  return clientFactory.build(overrides);
-}

package/src/test-utils/factories/talkpilot/results.ts

@@ -1,43 +0,0 @@
-import { Factory } from "fishery";
-import { ObjectId } from "mongodb";
-import { faker } from "@faker-js/faker";
-import type { Result, CallResult } from "../../../talkpilot";
-
-export const callResultFactory = Factory.define<CallResult>(() => ({
-  callSid: `CA${faker.string.alphanumeric(32)}`,
-  status: "completed",
-  date: new Date(),
-  statuses: ["completed"],
-  userAnswer: null,
-  color: null,
-  name: null,
-  callLength: "60 seconds",
-  answeredBy: null,
-  to: faker.phone.number(),
-  from: faker.phone.number(),
-  transcription: [],
-  flowId: new ObjectId().toString(),
-  recordingUrl: null,
-}));
-
-export function createCallResult(overrides?: Partial<CallResult>): CallResult {
-  return callResultFactory.build(overrides);
-}
-
-export const resultFactory = Factory.define<Result & { _id?: ObjectId }>(
-  () => ({
-    _id: new ObjectId(),
-    calls: [],
-    clientId: faker.string.uuid(),
-    date: new Date(),
-    runId: `run_${new ObjectId().toString()}`,
-    sessionId: "incomingCall",
-    sessionName: "incomingCall",
-  }),
-);
-
-export function createResult(
-  overrides?: Partial<Result>,
-): Result & { _id?: ObjectId } {
-  return resultFactory.build(overrides);
-}

package/src/utils/regex.utils.ts

@@ -1,2 +0,0 @@
-export const escapeRegex = (text: string): string =>
-  text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");