@talkpilot/core-db 1.1.8 → 1.1.9

package/src/municipal/systemInstructions/instructions.setters.ts

@@ -1,7 +1,11 @@
-import { ObjectId } from '../index';
-import { ObjectId as MongoObjectId } from 'mongodb';
-import { MIS_SystemInstruction, MIS_TOOLS, QUERY_TYPES } from './instructions.types';
-import { getSystemInstructionsCollection } from './instructions.getters';
+import { ObjectId } from "../index";
+import { ObjectId as MongoObjectId } from "mongodb";
+import {
+  MIS_SystemInstruction,
+  MIS_TOOLS,
+  QUERY_TYPES,
+} from "./instructions.types";
+import { getSystemInstructionsCollection } from "./instructions.getters";
 
 /**
  * Validate system instruction data
@@ -9,11 +13,21 @@ import { getSystemInstructionsCollection } from './instructions.getters';
  * @throws Error if tool or queryType is invalid
  */
 const validateInstructionData = (data: Partial<MIS_SystemInstruction>) => {
-  if (data.tool && !(Object.values(MIS_TOOLS) as string[]).includes(data.tool)) {
-    throw new Error(`Invalid tool value: ${data.tool}. Allowed values are: ${Object.values(MIS_TOOLS).join(', ')}`);
+  if (
+    data.tool &&
+    !(Object.values(MIS_TOOLS) as string[]).includes(data.tool)
+  ) {
+    throw new Error(
+      `Invalid tool value: ${data.tool}. Allowed values are: ${Object.values(MIS_TOOLS).join(", ")}`,
+    );
   }
-  if (data.queryType && !(Object.values(QUERY_TYPES) as string[]).includes(data.queryType)) {
-    throw new Error(`Invalid queryType value: ${data.queryType}. Allowed values are: ${Object.values(QUERY_TYPES).join(', ')}`);
+  if (
+    data.queryType &&
+    !(Object.values(QUERY_TYPES) as string[]).includes(data.queryType)
+  ) {
+    throw new Error(
+      `Invalid queryType value: ${data.queryType}. Allowed values are: ${Object.values(QUERY_TYPES).join(", ")}`,
+    );
   }
 };
 
@@ -23,16 +37,20 @@ const validateInstructionData = (data: Partial<MIS_SystemInstruction>) => {
  * @returns inserted system instruction id
  */
 export const createSystemInstruction = async (
-  instructionData: Omit<MIS_SystemInstruction, '_id' | 'createdAt' | 'updatedAt'>
+  instructionData: Omit<
+    MIS_SystemInstruction,
+    "_id" | "createdAt" | "updatedAt"
+  >,
 ): Promise<MongoObjectId> => {
   validateInstructionData(instructionData as Partial<MIS_SystemInstruction>);
-  const instruction: Omit<MIS_SystemInstruction, '_id'> = { //append doc metadata to user provided data
+  const instruction: Omit<MIS_SystemInstruction, "_id"> = {
+    //append doc metadata to user provided data
     ...instructionData,
     createdAt: new Date(),
     updatedAt: new Date(),
   };
   const { insertedId } = await getSystemInstructionsCollection().insertOne(
-    instruction as MIS_SystemInstruction
+    instruction as MIS_SystemInstruction,
   );
   return insertedId;
 };
@@ -45,13 +63,13 @@ export const createSystemInstruction = async (
  */
 export const updateSystemInstruction = async (
   id: string,
-  data: Partial<Omit<MIS_SystemInstruction, '_id' | 'createdAt' | 'updatedAt'>>
+  data: Partial<Omit<MIS_SystemInstruction, "_id" | "createdAt" | "updatedAt">>,
 ): Promise<MIS_SystemInstruction | null> => {
   validateInstructionData(data as Partial<MIS_SystemInstruction>);
   const result = await getSystemInstructionsCollection().findOneAndUpdate(
     { _id: new ObjectId(id) },
     { $set: { ...data, updatedAt: new Date() } },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
   return result || null;
 };
@@ -62,7 +80,9 @@ export const updateSystemInstruction = async (
  * @returns true if deleted, false otherwise
  */
 export const deleteSystemInstruction = async (id: string): Promise<boolean> => {
-  const result = await getSystemInstructionsCollection().deleteOne({ _id: new ObjectId(id) });
+  const result = await getSystemInstructionsCollection().deleteOne({
+    _id: new ObjectId(id),
+  });
   return result.deletedCount > 0;
 };
 /**
@@ -71,11 +91,13 @@ export const deleteSystemInstruction = async (id: string): Promise<boolean> => {
  * @param id system instruction id
  * @returns true on success, false otherwise
  */
-export const activateSystemInstruction = async (id: string): Promise<boolean> => {
+export const activateSystemInstruction = async (
+  id: string,
+): Promise<boolean> => {
   const result = await getSystemInstructionsCollection().findOneAndUpdate(
     { _id: new ObjectId(id) },
     { $set: { isActive: true } },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
   return Boolean(result);
 };
@@ -85,11 +107,13 @@ export const activateSystemInstruction = async (id: string): Promise<boolean> =>
  * @param id system instruction id
  * @returns true on success, false otherwise
  */
-export const deactivateSystemInstruction = async (id: string): Promise<boolean> => {
+export const deactivateSystemInstruction = async (
+  id: string,
+): Promise<boolean> => {
   const result = await getSystemInstructionsCollection().findOneAndUpdate(
     { _id: new ObjectId(id) },
     { $set: { isActive: false } },
-      {returnDocument: 'after'}
+    { returnDocument: "after" },
   );
   return Boolean(result);
-}
+};

package/src/municipal/systemInstructions/instructions.types.ts

@@ -1,21 +1,21 @@
-import { ObjectId } from 'mongodb';
+import { ObjectId } from "mongodb";
 
-import {CityName} from "../utils/types";
+import { CityName } from "../utils/types";
 
 export const MIS_TOOLS = {
-  findStreet: 'findStreet',
-  findSubject: 'findSubject'
+  findStreet: "findStreet",
+  findSubject: "findSubject",
 } as const;
 
 export const QUERY_TYPES = {
-  exactlyOne: 'exactlyOne',
-  any: 'any',
-  all: 'all',
-  none: 'none'
+  exactlyOne: "exactlyOne",
+  any: "any",
+  all: "all",
+  none: "none",
 } as const;
 
-export type MIS_Tool = typeof MIS_TOOLS[keyof typeof MIS_TOOLS];
-export type QueryType = typeof QUERY_TYPES[keyof typeof QUERY_TYPES];
+export type MIS_Tool = (typeof MIS_TOOLS)[keyof typeof MIS_TOOLS];
+export type QueryType = (typeof QUERY_TYPES)[keyof typeof QUERY_TYPES];
 
 export type MIS_SystemInstruction = {
   _id: ObjectId;

package/src/municipal/tickets/__tests__/tickets.getters.spec.ts

@@ -1,14 +1,14 @@
-import { findTicketsByCallSid } from '../tickets.getters';
-import { setDb } from '../../index';
-import { Db, Collection } from 'mongodb';
-import { createTicket } from '../../../test-utils/factories';
+import { findTicketsByCallSid } from "../tickets.getters";
+import { setDb } from "../../index";
+import { Db, Collection } from "mongodb";
+import { createTicket } from "../../../test-utils/factories";
 
-describe('tickets getters', () => {
+describe("tickets getters", () => {
   let mockDb: Partial<Db>;
   let mockCollection: Partial<Collection>;
 
   beforeEach(() => {
-    const mockTicket = createTicket({ callSid: '123' });
+    const mockTicket = createTicket({ callSid: "123" });
     mockCollection = {
       find: jest.fn().mockReturnValue({
         toArray: jest.fn().mockResolvedValue([mockTicket]),
@@ -20,11 +20,11 @@ describe('tickets getters', () => {
     setDb(mockDb as Db);
   });
 
-  it('findTicketsByCallSid should return tickets for the given callSid', async () => {
-    const result = await findTicketsByCallSid('123');
-    
-    expect(mockDb.collection).toHaveBeenCalledWith('tickets');
-    expect(mockCollection.find).toHaveBeenCalledWith({ callSid: '123' });
-    expect(result[0].callSid).toBe('123');
+  it("findTicketsByCallSid should return tickets for the given callSid", async () => {
+    const result = await findTicketsByCallSid("123");
+
+    expect(mockDb.collection).toHaveBeenCalledWith("tickets");
+    expect(mockCollection.find).toHaveBeenCalledWith({ callSid: "123" });
+    expect(result[0].callSid).toBe("123");
   });
 });

package/src/municipal/tickets/index.ts

@@ -1,2 +1,2 @@
-export * from './tickets.getters';
-export type { Ticket, TicketDoc, SubjectStatsItem } from './tickets.types';
+export * from "./tickets.getters";
+export type { Ticket, TicketDoc, SubjectStatsItem } from "./tickets.types";

package/src/municipal/tickets/tickets.getters.ts

@@ -1,6 +1,6 @@
-import {CityName, getDb, ObjectId, Ticket} from '../index';
-import type { SubjectStatsItem } from './tickets.types';
-import { Collection, Filter, ObjectId as MongoObjectId } from 'mongodb';
+import { CityName, getDb, ObjectId, Ticket } from "../index";
+import type { SubjectStatsItem } from "./tickets.types";
+import { Collection, Filter, ObjectId as MongoObjectId } from "mongodb";
 
 /**
  * Generate a new ticket ID as a string
@@ -11,25 +11,33 @@ export const generateTicketId = (): string => {
 };
 
 export const getTicketsCollection = (): Collection<Ticket> => {
-  return getDb().collection<Ticket>('tickets');
+  return getDb().collection<Ticket>("tickets");
 };
 
-export const findTickets = async (filter: Filter<Ticket> = {}): Promise<Ticket[]> => {
+export const findTickets = async (
+  filter: Filter<Ticket> = {},
+): Promise<Ticket[]> => {
   return await getTicketsCollection().find(filter).toArray();
 };
 
-export const findTicketsByCallSid = async (callSid: string): Promise<Ticket[]> => {
+export const findTicketsByCallSid = async (
+  callSid: string,
+): Promise<Ticket[]> => {
   return await getTicketsCollection().find({ callSid }).toArray();
 };
 
-export const getTicketById = async (ticketId: string): Promise<Ticket | null> => {
-  const ticket = await getTicketsCollection().findOne({ _id: new ObjectId(ticketId) });
+export const getTicketById = async (
+  ticketId: string,
+): Promise<Ticket | null> => {
+  const ticket = await getTicketsCollection().findOne({
+    _id: new ObjectId(ticketId),
+  });
   return ticket ? ticket : null;
 };
 
 export const createTicket = async (
-  ticketData: Omit<Ticket, '_id' | 'createdAt' | 'updatedAt'>,
-  ticketId?: string
+  ticketData: Omit<Ticket, "_id" | "createdAt" | "updatedAt">,
+  ticketId?: string,
 ): Promise<MongoObjectId> => {
   const ticket: Ticket = {
     _id: ticketId ? new ObjectId(ticketId) : new ObjectId(),
@@ -43,18 +51,20 @@ export const createTicket = async (
 
 export const updateTicket = async (
   ticketId: string,
-  data: Partial<Omit<Ticket, '_id' | 'createdAt' | 'updatedAt'>>
+  data: Partial<Omit<Ticket, "_id" | "createdAt" | "updatedAt">>,
 ): Promise<Ticket | null> => {
   const result = await getTicketsCollection().findOneAndUpdate(
     { _id: new ObjectId(ticketId) },
     { $set: { ...data, updatedAt: new Date() } },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
   return result || null;
 };
 
 export const deleteTicket = async (ticketId: string): Promise<boolean> => {
-  const result = await getTicketsCollection().deleteOne({ _id: new ObjectId(ticketId) });
+  const result = await getTicketsCollection().deleteOne({
+    _id: new ObjectId(ticketId),
+  });
   return result.deletedCount > 0;
 };
 
@@ -66,7 +76,7 @@ export async function getTicketsCountByCityAndDateRange(
   cityName: string,
   startStr: string,
   endStr: string,
-  timezone: string
+  timezone: string,
 ): Promise<number> {
   const doc = await getTicketsCollection()
     .aggregate<{ n: number }>([
@@ -74,12 +84,12 @@ export async function getTicketsCountByCityAndDateRange(
       {
         $addFields: {
           dateLocal: {
-            $dateToString: { format: '%Y-%m-%d', date: '$createdAt', timezone },
+            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
           },
         },
       },
       { $match: { dateLocal: { $gte: startStr, $lte: endStr } } },
-      { $count: 'n' },
+      { $count: "n" },
     ])
     .next();
   return doc?.n ?? 0;
@@ -93,7 +103,7 @@ export async function getTicketsSubjectStats(
   cityName: string,
   startStr: string,
   endStr: string,
-  timezone: string
+  timezone: string,
 ): Promise<SubjectStatsItem[]> {
   const coll = getTicketsCollection();
   const rows = await coll
@@ -102,7 +112,7 @@ export async function getTicketsSubjectStats(
       {
         $addFields: {
           dateLocal: {
-            $dateToString: { format: '%Y-%m-%d', date: '$createdAt', timezone },
+            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
           },
         },
       },
@@ -111,11 +121,11 @@ export async function getTicketsSubjectStats(
         $addFields: {
           effectiveSubjectId: {
             $ifNull: [
-              '$externalCallFields.event_subject_id',
+              "$externalCallFields.event_subject_id",
               {
                 $ifNull: [
-                  '$externalCallFields.event_sub_subject_id',
-                  '$externalCallFields.event_sub_subject_id2',
+                  "$externalCallFields.event_sub_subject_id",
+                  "$externalCallFields.event_sub_subject_id2",
                 ],
               },
             ],
@@ -124,19 +134,23 @@ export async function getTicketsSubjectStats(
       },
       {
         $lookup: {
-          from: 'departmentsSubjects',
-          let: { sid: '$effectiveSubjectId', c: cityName },
+          from: "departmentsSubjects",
+          let: { sid: "$effectiveSubjectId", c: cityName },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
-                    { $eq: ['$cityName', '$$c'] },
+                    { $eq: ["$cityName", "$$c"] },
                     {
                       $or: [
-                        { $eq: ['$subject_id', { $ifNull: ['$$sid', ''] }] },
-                        { $eq: ['$sub_subject_id', { $ifNull: ['$$sid', ''] }] },
-                        { $eq: ['$sub_subject_id2', { $ifNull: ['$$sid', ''] }] },
+                        { $eq: ["$subject_id", { $ifNull: ["$$sid", ""] }] },
+                        {
+                          $eq: ["$sub_subject_id", { $ifNull: ["$$sid", ""] }],
+                        },
+                        {
+                          $eq: ["$sub_subject_id2", { $ifNull: ["$$sid", ""] }],
+                        },
                       ],
                     },
                   ],
@@ -145,28 +159,41 @@ export async function getTicketsSubjectStats(
             },
             { $limit: 1 },
           ],
-          as: 'subj',
+          as: "subj",
         },
       },
       {
         $addFields: {
           subject_id: {
             $cond: {
-              if: { $gt: [{ $size: '$subj' }, 0] },
-              then: { $ifNull: [{ $arrayElemAt: ['$subj.subject_id', 0] }, ''] },
-              else: '',
+              if: { $gt: [{ $size: "$subj" }, 0] },
+              then: {
+                $ifNull: [{ $arrayElemAt: ["$subj.subject_id", 0] }, ""],
+              },
+              else: "",
             },
           },
           subject: {
             $cond: {
-              if: { $gt: [{ $size: '$subj' }, 0] },
-              then: { $ifNull: [{ $arrayElemAt: ['$subj.subjectName', 0] }, 'Unclassified'] },
-              else: 'Unclassified',
+              if: { $gt: [{ $size: "$subj" }, 0] },
+              then: {
+                $ifNull: [
+                  { $arrayElemAt: ["$subj.subjectName", 0] },
+                  "Unclassified",
+                ],
+              },
+              else: "Unclassified",
             },
           },
         },
       },
-      { $group: { _id: '$subject_id', subject: { $first: '$subject' }, count: { $sum: 1 } } },
+      {
+        $group: {
+          _id: "$subject_id",
+          subject: { $first: "$subject" },
+          count: { $sum: 1 },
+        },
+      },
       { $sort: { count: -1 } },
     ])
     .toArray();
@@ -196,21 +223,21 @@ export const updateTicketFilesByCallNumber = async (params: {
   const { cityName, callNumber, image1, image2, image3 } = params;
 
   const update: any = {};
-  if (image1) update['externalCallFields.image1'] = image1;
-  if (image2) update['externalCallFields.image2'] = image2;
-  if (image3) update['externalCallFields.image3'] = image3;
+  if (image1) update["externalCallFields.image1"] = image1;
+  if (image2) update["externalCallFields.image2"] = image2;
+  if (image3) update["externalCallFields.image3"] = image3;
 
   const result = await getTicketsCollection().updateOne(
     {
       cityName: cityName,
-      'externalCallFields.call_number': callNumber,
+      "externalCallFields.call_number": callNumber,
     },
     {
       $set: {
         ...update,
         updatedAt: new Date(),
       },
-    }
+    },
   );
 
   return result.matchedCount > 0;
@@ -226,8 +253,8 @@ export const clearGuestJwtByCallNumber = async (params: {
   const { cityName, callNumber } = params;
 
   const result = await getTicketsCollection().updateOne(
-    { cityName, 'externalCallFields.call_number': callNumber },
-    { $unset: { guestJwt: '' }, $set: { updatedAt: new Date() } }
+    { cityName, "externalCallFields.call_number": callNumber },
+    { $unset: { guestJwt: "" }, $set: { updatedAt: new Date() } },
   );
 
   return result.matchedCount > 0;

package/src/municipal/tickets/tickets.types.ts

@@ -1,6 +1,6 @@
-import { ObjectId, WithId } from 'mongodb';
+import { ObjectId, WithId } from "mongodb";
 
-import {CityName} from "../utils/types";
+import { CityName } from "../utils/types";
 
 export type Ticket = {
   _id: ObjectId;

package/src/municipal/utils/types.ts

@@ -1,6 +1,11 @@
-
-
 /**
  * City name type for municipal data
  */
-export type CityName = 'ashdod' | 'maltar' | 'billit' | 'hashkelon' | 'eilat' | 'tests' | string;
+export type CityName =
+  | "ashdod"
+  | "maltar"
+  | "billit"
+  | "hashkelon"
+  | "eilat"
+  | "tests"
+  | string;

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

@@ -8,25 +8,25 @@ import {
   ObjectId,
   getPlansCollection,
   getSubscriptionsCollection,
-} from '../index';
+} from "../index";
 
-import { ObjectId as MongoObjectId } from 'mongodb';
+import { ObjectId as MongoObjectId } from "mongodb";
 
-describe('talkpilot core/db', () => {
+describe("talkpilot core/db", () => {
   it.each([
-    ['flows', getFlowsCollection],
-    ['sessions', getSessionsCollection],
-    ['results', getResultsCollection],
-    ['leads', getLeadsCollection],
-    ['phone_numbers', getPhoneNumbersCollection],
-    ['clients', getClientsCollection],
-    ['plans', getPlansCollection],
-    ['subscriptions', getSubscriptionsCollection],
+    ["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', () => {
+  it("ObjectId re-export behaves like mongodb.ObjectId", () => {
     expect(ObjectId).toBe(MongoObjectId);
 
     const id = new ObjectId();

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

@@ -1,19 +1,18 @@
-import { mongodbClient } from '../mongodb-client';
-import { getDb } from '../index';
+import { getDb } from "../index";
 
-describe('MongoDBClient', () => {
-  it('should have a connected database instance from global setup', () => {
+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
+    expect(db.databaseName).toBe("test"); // Based on our setup.ts
   });
 
-  it('should report as connected', async () => {
+  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); 
+    expect(true).toBe(true);
   });
 });

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

@@ -1,7 +1,7 @@
-import { mongodbClient } from '../mongodb-client';
-import { MongoClient } from 'mongodb';
+import { mongodbClient } from "../mongodb-client";
+import { MongoClient } from "mongodb";
 
-describe('MongoDBClient Validation', () => {
+describe("MongoDBClient Validation", () => {
   const originalEnv = process.env;
 
   beforeEach(() => {
@@ -9,7 +9,7 @@ describe('MongoDBClient Validation', () => {
     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;
@@ -21,41 +21,47 @@ describe('MongoDBClient Validation', () => {
     await mongodbClient.disconnect();
   });
 
-  it('should throw error if no URI is provided', async () => {
+  it("should throw error if no URI is provided", async () => {
     await expect(mongodbClient.connect()).rejects.toThrow(
-      "[core-db] Configuration Error: 'MONGO_URI' is missing"
+      "[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 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 () => {
+  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'; 
+    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"
+      "[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';
+  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');
-    
+    expect(mongodbClient.getDb().databaseName).toBe("my-db");
+
     connectSpy.mockRestore();
     dbSpy.mockRestore();
   });