@talkpilot/core-db 1.3.50 → 1.3.52

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

@@ -1,38 +1,38 @@
-import {
-  getFlowsCollection,
-  getSessionsCollection,
-  getResultsCollection,
-  getLeadsCollection,
-  getPhoneNumbersCollection,
-  getClientsCollection,
-  ObjectId,
-  getPlansCollection,
-  getSubscriptionsCollection,
-} from "../index";
-
-import { ObjectId as MongoObjectId } from "mongodb";
-
-describe("talkpilot core/db", () => {
-  it.each([
-    ["flows", getFlowsCollection],
-    ["sessions", getSessionsCollection],
-    ["results", getResultsCollection],
-    ["leads", getLeadsCollection],
-    ["phone_numbers", getPhoneNumbersCollection],
-    ["clients", getClientsCollection],
-    ["plans", getPlansCollection],
-    ["subscriptions", getSubscriptionsCollection],
-  ])('%s collection helper returns a "%s" collection', (name, getter) => {
-    expect(getter().collectionName).toBe(name);
-  });
-
-  it("ObjectId re-export behaves like mongodb.ObjectId", () => {
-    expect(ObjectId).toBe(MongoObjectId);
-
-    const id = new ObjectId();
-
-    expect(id).toBeInstanceOf(MongoObjectId);
-    expect(ObjectId.isValid(id)).toBe(true);
-    expect(id.toHexString()).toHaveLength(24);
-  });
-});
+import {
+  getFlowsCollection,
+  getSessionsCollection,
+  getResultsCollection,
+  getLeadsCollection,
+  getPhoneNumbersCollection,
+  getClientsCollection,
+  ObjectId,
+  getPlansCollection,
+  getSubscriptionsCollection,
+} from "../index";
+
+import { ObjectId as MongoObjectId } from "mongodb";
+
+describe("talkpilot core/db", () => {
+  it.each([
+    ["flows", getFlowsCollection],
+    ["sessions", getSessionsCollection],
+    ["results", getResultsCollection],
+    ["leads", getLeadsCollection],
+    ["phone_numbers", getPhoneNumbersCollection],
+    ["clients", getClientsCollection],
+    ["plans", getPlansCollection],
+    ["subscriptions", getSubscriptionsCollection],
+  ])('%s collection helper returns a "%s" collection', (name, getter) => {
+    expect(getter().collectionName).toBe(name);
+  });
+
+  it("ObjectId re-export behaves like mongodb.ObjectId", () => {
+    expect(ObjectId).toBe(MongoObjectId);
+
+    const id = new ObjectId();
+
+    expect(id).toBeInstanceOf(MongoObjectId);
+    expect(ObjectId.isValid(id)).toBe(true);
+    expect(id.toHexString()).toHaveLength(24);
+  });
+});

package/src/talkpilot/__tests__/mongodb-client.spec.ts

@@ -1,18 +1,18 @@
-import { getDb } from "../index";
-
-describe("MongoDBClient", () => {
-  it("should have a connected database instance from global setup", () => {
-    const db = getDb();
-    expect(db).toBeDefined();
-    expect(db.databaseName).toBe("test"); // Based on our setup.ts
-  });
-
-  it("should report as connected", async () => {
-    // Note: mongodbClient.connect() was called in global setup
-    // but through setDb, not necessarily through the client singleton instance
-    // since initTestDb calls setDb directly.
-
-    // In a real scenario, you'd use the client.
-    expect(true).toBe(true);
-  });
-});
+import { getDb } from "../index";
+
+describe("MongoDBClient", () => {
+  it("should have a connected database instance from global setup", () => {
+    const db = getDb();
+    expect(db).toBeDefined();
+    expect(db.databaseName).toBe("test"); // Based on our setup.ts
+  });
+
+  it("should report as connected", async () => {
+    // Note: mongodbClient.connect() was called in global setup
+    // but through setDb, not necessarily through the client singleton instance
+    // since initTestDb calls setDb directly.
+
+    // In a real scenario, you'd use the client.
+    expect(true).toBe(true);
+  });
+});

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

@@ -1,68 +1,68 @@
-import { mongodbClient } from "../mongodb-client";
-import { MongoClient } from "mongodb";
-
-describe("MongoDBClient Validation", () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    process.env = { ...originalEnv };
-    delete process.env.MONGO_URI;
-    delete process.env.MONGODB_URI;
-    delete process.env.MONGODB_DB_NAME;
-
-    // Force reset singleton state
-    (mongodbClient as any).client = null;
-    (mongodbClient as any).db = null;
-  });
-
-  afterAll(async () => {
-    process.env = originalEnv;
-    // Ensure we are disconnected
-    await mongodbClient.disconnect();
-  });
-
-  it("should throw error if no URI is provided", async () => {
-    await expect(mongodbClient.connect()).rejects.toThrow(
-      "[core-db] Configuration Error: 'MONGO_URI' is missing",
-    );
-  });
-
-  it("should throw error if an invalid URI format is provided", async () => {
-    await expect(mongodbClient.connect("not-a-mongo-uri")).rejects.toThrow(
-      "[core-db] Connection Error: The provided MongoDB URI is invalid",
-    );
-  });
-
-  it("should throw error if URI is valid but database name is missing", async () => {
-    // We mock the actual MongoClient connection so it doesn't try to hit a real network
-    const connectSpy = jest
-      .spyOn(MongoClient.prototype, "connect")
-      .mockResolvedValue({} as any);
-
-    const uriWithoutDb = "mongodb://127.0.0.1:27017";
-    await expect(mongodbClient.connect(uriWithoutDb)).rejects.toThrow(
-      "[core-db] Database name not specified",
-    );
-
-    connectSpy.mockRestore();
-  });
-
-  it("should succeed when valid URI and DB name are provided", async () => {
-    const mockDb = { databaseName: "my-db" };
-    const connectSpy = jest
-      .spyOn(MongoClient.prototype, "connect")
-      .mockResolvedValue({} as any);
-    const dbSpy = jest
-      .spyOn(MongoClient.prototype, "db")
-      .mockReturnValue(mockDb as any);
-
-    const validUri = "mongodb://127.0.0.1:27017/my-db";
-    await mongodbClient.connect(validUri);
-
-    expect(mongodbClient.getDb()).toBeDefined();
-    expect(mongodbClient.getDb().databaseName).toBe("my-db");
-
-    connectSpy.mockRestore();
-    dbSpy.mockRestore();
-  });
-});
+import { mongodbClient } from "../mongodb-client";
+import { MongoClient } from "mongodb";
+
+describe("MongoDBClient Validation", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    delete process.env.MONGO_URI;
+    delete process.env.MONGODB_URI;
+    delete process.env.MONGODB_DB_NAME;
+
+    // Force reset singleton state
+    (mongodbClient as any).client = null;
+    (mongodbClient as any).db = null;
+  });
+
+  afterAll(async () => {
+    process.env = originalEnv;
+    // Ensure we are disconnected
+    await mongodbClient.disconnect();
+  });
+
+  it("should throw error if no URI is provided", async () => {
+    await expect(mongodbClient.connect()).rejects.toThrow(
+      "[core-db] Configuration Error: 'MONGO_URI' is missing",
+    );
+  });
+
+  it("should throw error if an invalid URI format is provided", async () => {
+    await expect(mongodbClient.connect("not-a-mongo-uri")).rejects.toThrow(
+      "[core-db] Connection Error: The provided MongoDB URI is invalid",
+    );
+  });
+
+  it("should throw error if URI is valid but database name is missing", async () => {
+    // We mock the actual MongoClient connection so it doesn't try to hit a real network
+    const connectSpy = jest
+      .spyOn(MongoClient.prototype, "connect")
+      .mockResolvedValue({} as any);
+
+    const uriWithoutDb = "mongodb://127.0.0.1:27017";
+    await expect(mongodbClient.connect(uriWithoutDb)).rejects.toThrow(
+      "[core-db] Database name not specified",
+    );
+
+    connectSpy.mockRestore();
+  });
+
+  it("should succeed when valid URI and DB name are provided", async () => {
+    const mockDb = { databaseName: "my-db" };
+    const connectSpy = jest
+      .spyOn(MongoClient.prototype, "connect")
+      .mockResolvedValue({} as any);
+    const dbSpy = jest
+      .spyOn(MongoClient.prototype, "db")
+      .mockReturnValue(mockDb as any);
+
+    const validUri = "mongodb://127.0.0.1:27017/my-db";
+    await mongodbClient.connect(validUri);
+
+    expect(mongodbClient.getDb()).toBeDefined();
+    expect(mongodbClient.getDb().databaseName).toBe("my-db");
+
+    connectSpy.mockRestore();
+    dbSpy.mockRestore();
+  });
+});

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

@@ -1,29 +1,29 @@
-import { findAgents } from "../agents.getters";
-import { setDb } from "../../index";
-import { Db, Collection } from "mongodb";
-import { createAgent } from "../../../test-utils/factories";
-
-describe("agents getters", () => {
-  let mockDb: Partial<Db>;
-  let mockCollection: Partial<Collection>;
-
-  beforeEach(() => {
-    const mockAgent = createAgent({ name: "Agent Smith" });
-    mockCollection = {
-      find: jest.fn().mockReturnValue({
-        toArray: jest.fn().mockResolvedValue([mockAgent]),
-      }),
-    };
-    mockDb = {
-      collection: jest.fn().mockReturnValue(mockCollection),
-    };
-    setDb(mockDb as Db);
-  });
-
-  it("findAgents should return agents", async () => {
-    const result = await findAgents();
-
-    expect(mockDb.collection).toHaveBeenCalledWith("agents");
-    expect(result[0].name).toBe("Agent Smith");
-  });
-});
+import { findAgents } from "../agents.getters";
+import { setDb } from "../../index";
+import { Db, Collection } from "mongodb";
+import { createAgent } from "../../../test-utils/factories";
+
+describe("agents getters", () => {
+  let mockDb: Partial<Db>;
+  let mockCollection: Partial<Collection>;
+
+  beforeEach(() => {
+    const mockAgent = createAgent({ name: "Agent Smith" });
+    mockCollection = {
+      find: jest.fn().mockReturnValue({
+        toArray: jest.fn().mockResolvedValue([mockAgent]),
+      }),
+    };
+    mockDb = {
+      collection: jest.fn().mockReturnValue(mockCollection),
+    };
+    setDb(mockDb as Db);
+  });
+
+  it("findAgents should return agents", async () => {
+    const result = await findAgents();
+
+    expect(mockDb.collection).toHaveBeenCalledWith("agents");
+    expect(result[0].name).toBe("Agent Smith");
+  });
+});

package/src/talkpilot/agents/agents.getters.ts

@@ -1,34 +1,34 @@
-import { getDb, Agent, ObjectId } from "../index";
-
-export const getAgentsCollection = () => {
-  return getDb().collection<Agent>("agents");
-};
-
-export const findAgents = async (filter: any = {}) => {
-  return getAgentsCollection().find(filter).toArray();
-};
-
-export const findAgentById = (agentId: string) => {
-  return getAgentsCollection().findOne({ _id: new ObjectId(agentId) });
-};
-
-export const findAgentsByClientId = (clientId: string) => {
-  return getAgentsCollection().find({ clientId }).toArray();
-};
-
-export const createAgent = async (agent: Agent) => {
-  const { insertedId } = await getAgentsCollection().insertOne(agent);
-  return findAgentById(String(insertedId));
-};
-
-export const updateAgent = (agentId: string, data: Partial<Agent>) => {
-  return getAgentsCollection().findOneAndUpdate(
-    { _id: new ObjectId(agentId) },
-    { $set: data },
-    { returnDocument: "after" },
-  );
-};
-
-export const removeAgent = (agentId: string) => {
-  return getAgentsCollection().deleteOne({ _id: new ObjectId(agentId) });
-};
+import { getDb, Agent, ObjectId } from "../index";
+
+export const getAgentsCollection = () => {
+  return getDb().collection<Agent>("agents");
+};
+
+export const findAgents = async (filter: any = {}) => {
+  return getAgentsCollection().find(filter).toArray();
+};
+
+export const findAgentById = (agentId: string) => {
+  return getAgentsCollection().findOne({ _id: new ObjectId(agentId) });
+};
+
+export const findAgentsByClientId = (clientId: string) => {
+  return getAgentsCollection().find({ clientId }).toArray();
+};
+
+export const createAgent = async (agent: Agent) => {
+  const { insertedId } = await getAgentsCollection().insertOne(agent);
+  return findAgentById(String(insertedId));
+};
+
+export const updateAgent = (agentId: string, data: Partial<Agent>) => {
+  return getAgentsCollection().findOneAndUpdate(
+    { _id: new ObjectId(agentId) },
+    { $set: data },
+    { returnDocument: "after" },
+  );
+};
+
+export const removeAgent = (agentId: string) => {
+  return getAgentsCollection().deleteOne({ _id: new ObjectId(agentId) });
+};

package/src/talkpilot/agents/agents.types.ts

@@ -1,14 +1,14 @@
-import { WithId } from "mongodb";
-
-export type Agent = {
-  name: string;
-  language: string;
-  voice: string;
-  instructions: string;
-  labels: string[];
-  clientId: string;
-  role: string;
-  gender: "male" | "female";
-};
-
-export type AgentDoc = WithId<Agent>;
+import { WithId } from "mongodb";
+
+export type Agent = {
+  name: string;
+  language: string;
+  voice: string;
+  instructions: string;
+  labels: string[];
+  clientId: string;
+  role: string;
+  gender: "male" | "female";
+};
+
+export type AgentDoc = WithId<Agent>;

package/src/talkpilot/agents/index.ts

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

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

@@ -0,0 +1,92 @@
+import {
+  insertAuditLog,
+  getAuditLogsCollection,
+  findAuditLogs,
+  countAuditLogs,
+} from "../auditLogs.getters";
+import { AuditLogEntry } from "../auditLogs.types";
+
+describe("db.auditLogs", () => {
+  describe("insertAuditLog", () => {
+    it("should write an entry that can be read back with all fields intact", async () => {
+      const entry: AuditLogEntry = {
+        clientId: "deletedClient1",
+        adminEmail: "admin@callai.co.il",
+        action: "delete",
+        timestamp: new Date("2026-07-15T10:00:00.000Z"),
+        env: "prod",
+      };
+
+      await insertAuditLog(entry);
+
+      const stored = await getAuditLogsCollection().findOne({
+        clientId: "deletedClient1",
+      });
+      expect(stored).toMatchObject(entry);
+    });
+  });
+
+  describe("findAuditLogs", () => {
+    const seed = async () => {
+      await insertAuditLog({
+        clientId: "clientA",
+        adminEmail: "admin@callai.co.il",
+        action: "delete",
+        timestamp: new Date("2026-01-01T00:00:00.000Z"),
+      });
+      await insertAuditLog({
+        clientId: "clientB",
+        adminEmail: "admin@callai.co.il",
+        action: "delete",
+        timestamp: new Date("2026-02-01T00:00:00.000Z"),
+      });
+      await insertAuditLog({
+        clientId: "clientC",
+        adminEmail: "admin@callai.co.il",
+        action: "delete",
+        timestamp: new Date("2026-03-01T00:00:00.000Z"),
+      });
+    };
+
+    it("should return a page of entries, newest first", async () => {
+      await seed();
+
+      const page = await findAuditLogs({ limit: 2 });
+
+      expect(page).toHaveLength(2);
+      expect(page.map((e) => e.clientId)).toEqual(["clientC", "clientB"]);
+    });
+
+    it("should skip entries for later pages", async () => {
+      await seed();
+
+      const page = await findAuditLogs({ skip: 2, limit: 2 });
+
+      expect(page).toHaveLength(1);
+      expect(page[0].clientId).toBe("clientA");
+    });
+  });
+
+  describe("countAuditLogs", () => {
+    it("should return the total number of entries regardless of pagination", async () => {
+      await insertAuditLog({
+        clientId: "clientA",
+        adminEmail: "admin@callai.co.il",
+        action: "delete",
+        timestamp: new Date(),
+      });
+      await insertAuditLog({
+        clientId: "clientB",
+        adminEmail: "admin@callai.co.il",
+        action: "delete",
+        timestamp: new Date(),
+      });
+
+      expect(await countAuditLogs()).toBe(2);
+    });
+
+    it("should return 0 when there are no entries", async () => {
+      expect(await countAuditLogs()).toBe(0);
+    });
+  });
+});

package/src/talkpilot/auditLogs/auditLogs.getters.ts

@@ -0,0 +1,26 @@
+import { Collection } from "mongodb";
+import { getDb } from "../index";
+import { applyQueryOptions, QueryOptions } from "../utils/query.utils";
+import { AuditLogDoc, AuditLogEntry } from "./auditLogs.types";
+
+export const getAuditLogsCollection = (): Collection<AuditLogEntry> => {
+  return getDb().collection<AuditLogEntry>("auditLogs");
+};
+
+export const insertAuditLog = async (entry: AuditLogEntry): Promise<void> => {
+  await getAuditLogsCollection().insertOne(entry);
+};
+
+export const findAuditLogs = async (
+  options: Pick<QueryOptions, "skip"> & Required<Pick<QueryOptions, "limit">>,
+): Promise<AuditLogDoc[]> => {
+  const cursor = getAuditLogsCollection().find({});
+  return applyQueryOptions(cursor, {
+    sort: { timestamp: -1 },
+    ...options,
+  }).toArray();
+};
+
+export const countAuditLogs = async (): Promise<number> => {
+  return getAuditLogsCollection().countDocuments({});
+};

package/src/talkpilot/auditLogs/auditLogs.types.ts

@@ -0,0 +1,13 @@
+import { WithId } from "mongodb";
+
+export type AuditLogEntry = {
+  clientId: string;
+  adminEmail: string;
+  action: "delete";
+  timestamp: Date;
+  env?: string;
+  allSucceeded?: boolean;
+  failedCollections?: string[];
+};
+
+export type AuditLogDoc = WithId<AuditLogEntry>;

package/src/talkpilot/auditLogs/index.ts

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