@talkpilot/core-db 1.1.6 → 1.1.8

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

@@ -1,11 +1,7 @@
-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
@@ -13,21 +9,11 @@ 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(', ')}`);
   }
 };
 
@@ -37,20 +23,16 @@ 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;
 };
@@ -63,13 +45,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;
 };
@@ -80,9 +62,7 @@ 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;
 };
 /**
@@ -91,13 +71,11 @@ 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);
 };
@@ -107,13 +85,11 @@ export const activateSystemInstruction = async (
  * @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,33 +11,25 @@ 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(),
@@ -51,20 +43,18 @@ 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;
 };
 
@@ -76,7 +66,7 @@ export async function getTicketsCountByCityAndDateRange(
   cityName: string,
   startStr: string,
   endStr: string,
-  timezone: string,
+  timezone: string
 ): Promise<number> {
   const doc = await getTicketsCollection()
     .aggregate<{ n: number }>([
@@ -84,12 +74,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;
@@ -103,7 +93,7 @@ export async function getTicketsSubjectStats(
   cityName: string,
   startStr: string,
   endStr: string,
-  timezone: string,
+  timezone: string
 ): Promise<SubjectStatsItem[]> {
   const coll = getTicketsCollection();
   const rows = await coll
@@ -112,7 +102,7 @@ export async function getTicketsSubjectStats(
       {
         $addFields: {
           dateLocal: {
-            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
+            $dateToString: { format: '%Y-%m-%d', date: '$createdAt', timezone },
           },
         },
       },
@@ -121,11 +111,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',
                 ],
               },
             ],
@@ -134,23 +124,19 @@ 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', ''] }] },
                       ],
                     },
                   ],
@@ -159,41 +145,28 @@ 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();
@@ -223,21 +196,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;
@@ -253,8 +226,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,11 +1,6 @@
+
+
 /**
  * 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,18 +1,19 @@
-import { getDb } from "../index";
+import { mongodbClient } from '../mongodb-client';
+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,47 +21,41 @@ 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();
   });