@talkpilot/core-db 1.1.6 → 1.1.8

package/src/talkpilot/calls/calls.getters.ts

@@ -1,17 +1,11 @@
-import {
-  Call,
-  CallDoc,
-  CallQueryOptions,
-  CallUpdateParams,
-  getDb,
-} from "../index";
-import type { CallsByHour, CountOpts, DateRange } from "./calls.types";
-import { Filter, ObjectId } from "mongodb";
-import * as process from "node:process";
-import { applyQueryOptions } from "../utils/query.utils";
+import { getDb, Call, CallDoc, CallUpdateParams, CallQueryOptions } from '../index';
+import type { CallsByHour, CountOpts, DateRange } from './calls.types';
+import { ObjectId, Filter } from 'mongodb';
+import * as process from 'node:process';
+import { applyQueryOptions } from '../utils/query.utils';
 
 export const getCallsCollection = () => {
-  return getDb().collection<Call>("calls");
+  return getDb().collection<Call>('calls');
 };
 
 export const getCallByCallSid = (callSid: string) => {
@@ -19,9 +13,7 @@ export const getCallByCallSid = (callSid: string) => {
 };
 
 export const getCallsByPhoneNumber = (phoneNumber: string) => {
-  return getCallsCollection()
-    .find({ customerPhoneNumber: phoneNumber })
-    .toArray();
+  return getCallsCollection().find({ customerPhoneNumber: phoneNumber }).toArray();
 };
 
 export const getCallsByClient = (clientId: string) => {
@@ -32,22 +24,20 @@ export const getCallsByFlow = (flowId: ObjectId) => {
   return getCallsCollection().find({ flowId }).toArray();
 };
 
-export const createCallDoc = (
-  call: Omit<Call, "createdAt" | "updatedAt" | "env">,
-) => {
+export const createCallDoc = (call: Omit<Call, 'createdAt' | 'updatedAt' | 'env'>) => {
   return getCallsCollection().insertOne({
     ...call,
     createdAt: new Date(),
     updatedAt: new Date(),
-    env: process.env.ENV ?? "unknown",
+    env: process.env.ENV ?? 'unknown',
   });
 };
 
 export const updateCallByCallSid = async (
   callSid: string,
-  updates: CallUpdateParams,
+  updates: CallUpdateParams
 ): Promise<CallDoc | null> => {
-  return await getCallsCollection().findOneAndUpdate(
+  const result = await getCallsCollection().findOneAndUpdate(
     { callSid: callSid },
     {
       $set: {
@@ -55,17 +45,15 @@ export const updateCallByCallSid = async (
         updatedAt: new Date(),
       },
     },
-    { returnDocument: "after" },
+    { returnDocument: 'after' }
   );
+
+  return result;
 };
 
 // get calls by client and date range
 //client here is the user id
-export const getCallsByClientAndDateRange = (
-  clientId: string,
-  startDate: Date,
-  endDate: Date,
-) => {
+export const getCallsByClientAndDateRange = (clientId: string, startDate: Date, endDate: Date) => {
   return getCallsCollection()
     .find({
       clientId,
@@ -79,7 +67,7 @@ export const getCallsByClientAndDateRange = (
 
 export const findCallsByQuery = async (
   query: Filter<Call>,
-  options?: CallQueryOptions,
+  options?: CallQueryOptions
 ): Promise<CallDoc[]> => {
   const cursor = getCallsCollection().find(query);
   return await applyQueryOptions(cursor, options).toArray();
@@ -136,7 +124,7 @@ export const range = {
 
 export function startOfDay(d: Date = new Date()): Date {
   const x = new Date(d);
-  x.setUTCHours(0, 0, 0, 0);
+  x.setHours(0, 0, 0, 0);
   return x;
 }
 
@@ -154,29 +142,21 @@ export async function getCallsStatsForDateRange(
   clientId: string,
   startStr: string,
   endStr: string,
-  timezone: string,
+  timezone: string
 ): Promise<{ count: number; totalLen: number; completed: number }> {
   const coll = getCallsCollection();
   const out = await coll
-    .aggregate<{
-      _id: null;
-      count: number;
-      totalLen: number;
-      completed: number;
-    }>([
+    .aggregate<{ _id: null; count: number; totalLen: number; completed: number }>([
       // 1. Restrict to the given client
       { $match: { clientId } },
       // 2. Derive dateLocal (createdAt as YYYY-MM-DD in timezone) and isCompleted (agentHungUp or status='completed')
       {
         $addFields: {
           dateLocal: {
-            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
+            $dateToString: { format: '%Y-%m-%d', date: '$createdAt', timezone },
           },
           isCompleted: {
-            $or: [
-              { $eq: ["$agentHungUp", true] },
-              { $eq: ["$status", "completed"] },
-            ],
+            $or: [{ $eq: ['$agentHungUp', true] }, { $eq: ['$status', 'completed'] }],
           },
         },
       },
@@ -187,8 +167,8 @@ export async function getCallsStatsForDateRange(
         $group: {
           _id: null,
           count: { $sum: 1 },
-          totalLen: { $sum: "$callLength" },
-          completed: { $sum: { $cond: ["$isCompleted", 1, 0] } },
+          totalLen: { $sum: '$callLength' },
+          completed: { $sum: { $cond: ['$isCompleted', 1, 0] } },
         },
       },
     ])
@@ -206,7 +186,7 @@ export async function getCallsStatsForDateRange(
 export async function getCallsHourlyAggregation(
   clientId: string,
   dateStr: string,
-  timezone: string,
+  timezone: string
 ): Promise<CallsByHour[]> {
   const coll = getCallsCollection();
   const rows = await coll
@@ -217,22 +197,22 @@ export async function getCallsHourlyAggregation(
       {
         $addFields: {
           dateLocal: {
-            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
+            $dateToString: { format: '%Y-%m-%d', date: '$createdAt', timezone },
           },
-          hour: { $hour: { date: "$createdAt", timezone } },
+          hour: { $hour: { date: '$createdAt', timezone } },
         },
       },
       // 3. Keep only the requested date
       { $match: { dateLocal: dateStr } },
       // 4. Group by hour, sum calls per hour
-      { $group: { _id: "$hour", calls: { $sum: 1 } } },
+      { $group: { _id: '$hour', calls: { $sum: 1 } } },
       // 5. Order by hour ascending (0..23)
       { $sort: { _id: 1 } },
     ])
     .toArray();
 
   return rows.map((r: any) => ({
-    hour: `${String(r._id).padStart(2, "0")}:00`,
+    hour: `${String(r._id).padStart(2, '0')}:00`,
     calls: r.calls,
   }));
 }

package/src/talkpilot/calls/calls.types.ts

@@ -1,8 +1,8 @@
-import { ObjectId, Sort, WithId } from "mongodb";
-import { TranscriptionSegment } from "../results";
+import { ObjectId, Sort, WithId } from 'mongodb';
+import { TranscriptionSegment } from '../results/results.types';
 
-export const CONFERENCE_ROLE_CUSTOMER = "customer" as const;
-export const CONFERENCE_ROLE_SUPERVISOR = "supervisor" as const;
+export const CONFERENCE_ROLE_CUSTOMER = 'customer' as const;
+export const CONFERENCE_ROLE_SUPERVISOR = 'supervisor' as const;
 
 export type ConferenceRole =
   | typeof CONFERENCE_ROLE_CUSTOMER
@@ -62,18 +62,18 @@ export type CallsFilterParams = {
 };
 
 export type ImmutableCallFields =
-  | "customerPhoneNumber"
-  | "agentPhoneNumber"
-  | "isIncomingCall"
-  | "isOutgoingCall"
-  | "sessionId"
-  | "callSid"
-  | "flowId"
-  | "clientId"
-  | "runId"
-  | "resultId"
-  | "env"
-  | "createdAt";
+  | 'customerPhoneNumber'
+  | 'agentPhoneNumber'
+  | 'isIncomingCall'
+  | 'isOutgoingCall'
+  | 'sessionId'
+  | 'callSid'
+  | 'flowId'
+  | 'clientId'
+  | 'runId'
+  | 'resultId'
+  | 'env'
+  | 'createdAt';
 
 export type CallUpdateParams = Partial<Omit<Call, ImmutableCallFields>>;
 

package/src/talkpilot/calls/index.ts

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

package/src/talkpilot/clientAudioBuffers/__tests__/clientAudioBuffer.getters.spec.ts

@@ -4,66 +4,46 @@ import {
   findClientAudioBuffersByCallSidAndRange,
   getMergedAudioByCallSid,
   getAudioChunksByCallSid,
-} from "../clientAudioBuffer.getters";
-import { ObjectId } from "../../index";
-import { createAudioBufferInput } from "../../../test-utils/factories";
+} from '../clientAudioBuffer.getters';
+import { ObjectId } from '../../index';
+import { createAudioBufferInput } from '../../../test-utils/factories';
 
-describe("clientAudioBuffers getters", () => {
+describe('clientAudioBuffers getters', () => {
   it('should return the "clientAudioBuffers" collection', () => {
     const collection = getClientAudioBuffersCollection();
-    expect(collection.collectionName).toBe("clientAudioBuffers");
+    expect(collection.collectionName).toBe('clientAudioBuffers');
   });
 
-  it("should insert a client audio buffer and return insertedId", async () => {
+  it('should insert a client audio buffer and return insertedId', async () => {
     const inputToCheck = createAudioBufferInput();
     const result = await insertClientAudioBuffer(inputToCheck);
     expect(result.insertedId).toBeInstanceOf(ObjectId);
 
-    const savedDoc = await getClientAudioBuffersCollection().findOne({
-      _id: result.insertedId,
-    });
+    const savedDoc = await getClientAudioBuffersCollection().findOne({ _id: result.insertedId });
     expect(savedDoc).toBeDefined();
     expect(savedDoc?.createdAt).toBeInstanceOf(Date);
     expect(savedDoc?.expiresAt).toBeInstanceOf(Date);
   });
 
-  it("should return only buffers in the specified bucketStartMs range", async () => {
-    const callSid = "CA1234567890abcdef1234567890abcdef";
-    await insertClientAudioBuffer(
-      createAudioBufferInput({ callSid, bucketStartMs: 500 }),
-    );
-    await insertClientAudioBuffer(
-      createAudioBufferInput({ callSid, bucketStartMs: 1000 }),
-    );
-    await insertClientAudioBuffer(
-      createAudioBufferInput({ callSid, bucketStartMs: 3000 }),
-    );
-    await insertClientAudioBuffer(
-      createAudioBufferInput({ callSid, bucketStartMs: 6000 }),
-    );
+  it('should return only buffers in the specified bucketStartMs range', async () => {
+    const callSid = 'CA1234567890abcdef1234567890abcdef';
+    await insertClientAudioBuffer(createAudioBufferInput({ callSid, bucketStartMs: 500 }));
+    await insertClientAudioBuffer(createAudioBufferInput({ callSid, bucketStartMs: 1000 }));
+    await insertClientAudioBuffer(createAudioBufferInput({ callSid, bucketStartMs: 3000 }));
+    await insertClientAudioBuffer(createAudioBufferInput({ callSid, bucketStartMs: 6000 }));
 
-    const result = await findClientAudioBuffersByCallSidAndRange(
-      callSid,
-      500,
-      3000,
-    );
+    const result = await findClientAudioBuffersByCallSidAndRange(callSid, 500, 3000);
     expect(result).toHaveLength(3);
     const bucketStartValues = result.map((doc) => doc.bucketStartMs);
     const bucketStartsSorted = bucketStartValues.sort((a, b) => a - b);
     expect(bucketStartsSorted).toEqual([500, 1000, 3000]);
   });
 
-  it("should return all buffers when no range is provided", async () => {
-    const callSid = "CA1234567890abcdef1234567890abcdeg";
-    await insertClientAudioBuffer(
-      createAudioBufferInput({ callSid, bucketStartMs: 500 }),
-    );
-    await insertClientAudioBuffer(
-      createAudioBufferInput({ callSid, bucketStartMs: 1000 }),
-    );
-    await insertClientAudioBuffer(
-      createAudioBufferInput({ callSid, bucketStartMs: 3000 }),
-    );
+  it('should return all buffers when no range is provided', async () => {
+    const callSid = 'CA1234567890abcdef1234567890abcdeg';
+    await insertClientAudioBuffer(createAudioBufferInput({ callSid, bucketStartMs: 500 }));
+    await insertClientAudioBuffer(createAudioBufferInput({ callSid, bucketStartMs: 1000 }));
+    await insertClientAudioBuffer(createAudioBufferInput({ callSid, bucketStartMs: 3000 }));
 
     const result = await findClientAudioBuffersByCallSidAndRange(callSid);
     expect(result).toHaveLength(3);
@@ -72,33 +52,21 @@ describe("clientAudioBuffers getters", () => {
     expect(bucketStartsSorted).toEqual([500, 1000, 3000]);
   });
 
-  it("should merge audio buffers by callSid in chronological order", async () => {
-    const callSid = "CA1234567890abcdef1234567890abcdeh";
+  it('should merge audio buffers by callSid in chronological order', async () => {
+    const callSid = 'CA1234567890abcdef1234567890abcdeh';
 
     const firstBuffer = Buffer.from([1, 2]);
     const secondBuffer = Buffer.from([3]);
     const thirdBuffer = Buffer.from([4, 5]);
 
     await insertClientAudioBuffer(
-      createAudioBufferInput({
-        callSid,
-        bucketStartMs: 1000,
-        data: secondBuffer,
-      }),
+        createAudioBufferInput({ callSid, bucketStartMs: 1000, data: secondBuffer })
     );
     await insertClientAudioBuffer(
-      createAudioBufferInput({
-        callSid,
-        bucketStartMs: 500,
-        data: firstBuffer,
-      }),
+        createAudioBufferInput({ callSid, bucketStartMs: 500, data: firstBuffer })
     );
     await insertClientAudioBuffer(
-      createAudioBufferInput({
-        callSid,
-        bucketStartMs: 3000,
-        data: thirdBuffer,
-      }),
+        createAudioBufferInput({ callSid, bucketStartMs: 3000, data: thirdBuffer })
     );
 
     const merged = await getMergedAudioByCallSid(callSid, 10);
@@ -109,8 +77,8 @@ describe("clientAudioBuffers getters", () => {
     expect(merged.equals(expected)).toBe(true);
   });
 
-  it("should return all audio chunks when less than or equal to limit buffers exist", async () => {
-    const callSid = "CA1234567890abcdef1234567890abclt";
+  it('should return all audio chunks when less than or equal to limit buffers exist', async () => {
+    const callSid = 'CA1234567890abcdef1234567890abclt';
 
     const limit = 30;
     const buffers: Buffer[] = [];
@@ -118,11 +86,11 @@ describe("clientAudioBuffers getters", () => {
       const buf = Buffer.from([i]);
       buffers.push(buf);
       await insertClientAudioBuffer(
-        createAudioBufferInput({
-          callSid,
-          bucketStartMs: 1000 + i * 1000,
-          data: buf,
-        }),
+          createAudioBufferInput({
+            callSid,
+            bucketStartMs: 1000 + i * 1000,
+            data: buf,
+          })
       );
     }
 
@@ -133,8 +101,8 @@ describe("clientAudioBuffers getters", () => {
     expect(Buffer.concat(chunks).equals(Buffer.concat(buffers))).toBe(true);
   });
 
-  it("should return only the last N audio chunks when more than limit buffers exist", async () => {
-    const callSid = "CA1234567890abcdef1234567890abclm";
+  it('should return only the last N audio chunks when more than limit buffers exist', async () => {
+    const callSid = 'CA1234567890abcdef1234567890abclm';
 
     const limit = 30;
     const buffers: Buffer[] = [];
@@ -142,19 +110,17 @@ describe("clientAudioBuffers getters", () => {
       const buf = Buffer.from([i]);
       buffers.push(buf);
       await insertClientAudioBuffer(
-        createAudioBufferInput({
-          callSid,
-          bucketStartMs: 1000 + i * 1000,
-          data: buf,
-        }),
+          createAudioBufferInput({
+            callSid,
+            bucketStartMs: 1000 + i * 1000,
+            data: buf,
+          })
       );
     }
 
     const chunks = await getAudioChunksByCallSid(callSid, limit);
     const expectedBuffers = buffers.slice(-limit);
     expect(chunks).toHaveLength(expectedBuffers.length);
-    expect(Buffer.concat(chunks).equals(Buffer.concat(expectedBuffers))).toBe(
-      true,
-    );
+    expect(Buffer.concat(chunks).equals(Buffer.concat(expectedBuffers))).toBe(true);
   });
 });

package/src/talkpilot/clientAudioBuffers/clientAudioBuffer.getters.ts

@@ -1,18 +1,17 @@
-import { getDb } from "../index";
+import { getDb } from '../index';
 import {
   ClientAudioBufferDoc,
   ClientAudioBufferType,
   CreateAudioBufferInput,
-} from "./clientsAudioBuffers.types";
-import { Collection, InsertOneResult } from "mongodb";
+} from './clientsAudioBuffers.types';
+import { Collection, InsertOneResult } from 'mongodb';
 
-const getClientAudioBuffersCollection =
-  (): Collection<ClientAudioBufferType> => {
-    return getDb().collection<ClientAudioBufferType>("clientAudioBuffers");
-  };
+const getClientAudioBuffersCollection = (): Collection<ClientAudioBufferType> => {
+  return getDb().collection<ClientAudioBufferType>('clientAudioBuffers');
+};
 
 const insertClientAudioBuffer = async (
-  audioBufferInput: CreateAudioBufferInput,
+  audioBufferInput: CreateAudioBufferInput
 ): Promise<InsertOneResult<ClientAudioBufferType>> => {
   const collection = getClientAudioBuffersCollection();
   const realtimeDate = new Date();
@@ -28,7 +27,7 @@ const insertClientAudioBuffer = async (
   };
   const clientAudioBufferMongoDocument: ClientAudioBufferType = {
     ...inputFieldsForDocument,
-    codec: "mulaw",
+    codec: 'mulaw',
     sampleRateHz: 8000,
     channels: 1,
     createdAt: realtimeDate,
@@ -40,7 +39,7 @@ const insertClientAudioBuffer = async (
 const findClientAudioBuffersByCallSidAndRange = async (
   callSid: string,
   startMs?: number,
-  endMs?: number,
+  endMs?: number
 ): Promise<ClientAudioBufferDoc[]> => {
   const collection = getClientAudioBuffersCollection();
   if (startMs === undefined) {
@@ -58,10 +57,7 @@ const findClientAudioBuffersByCallSidAndRange = async (
     .toArray();
 };
 
-const getAudioChunksByCallSid = async (
-  callSid: string,
-  limit?: number,
-): Promise<Buffer[]> => {
+const getAudioChunksByCallSid = async (callSid: string, limit?: number): Promise<Buffer[]> => {
   const query = getClientAudioBuffersCollection().find({ callSid });
   if (limit) {
     query.sort({ bucketStartMs: -1 }).limit(limit);
@@ -84,10 +80,7 @@ const getAudioChunksByCallSid = async (
   });
 };
 
-const getMergedAudioByCallSid = async (
-  callSid: string,
-  limit: number,
-): Promise<Buffer> => {
+const getMergedAudioByCallSid = async (callSid: string, limit: number): Promise<Buffer> => {
   const buffers = await getAudioChunksByCallSid(callSid, limit);
 
   if (!buffers.length) {

package/src/talkpilot/clientAudioBuffers/clientsAudioBuffers.types.ts

@@ -1,11 +1,11 @@
-import { WithId } from "mongodb";
+import { WithId } from 'mongodb';
 
 export type ClientAudioBufferType = {
   callSid: string;
   clientId: string;
   bucketStartMs: number;
   bucketDurationMs: number;
-  codec: "mulaw";
+  codec: 'mulaw';
   sampleRateHz: 8000;
   channels: 1;
   data: Buffer;

package/src/talkpilot/clientAudioBuffers/index.ts

@@ -1,2 +1,2 @@
-export * from "./clientAudioBuffer.getters";
-export * from "./clientsAudioBuffers.types";
+export * from './clientAudioBuffer.getters';
+export * from './clientsAudioBuffers.types';

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

@@ -1,16 +1,11 @@
-import { getDb, Client } from "../index";
-import { Collection } from "mongodb";
+import { getDb, Client } from '../index';
+import { Collection } from 'mongodb';
 
 export const getClientsCollection = (): Collection<Client> => {
-  return getDb().collection<Client>("clients");
+  return getDb().collection<Client>('clients');
 };
 
-export const getClientByAPIKey = async (
-  apiKey: string,
-): Promise<Client | null> => {
-  const client = await getClientsCollection().findOne({
-    apiKey,
-    isActive: true,
-  });
+export const getClientByAPIKey = async (apiKey: string): Promise<Client | null> => {
+  const client = await getClientsCollection().findOne({ apiKey, isActive: true });
   return client ? client : null;
 };

package/src/talkpilot/clients/clients.types.ts

@@ -1,4 +1,4 @@
-import { ObjectId } from "mongodb";
+import { ObjectId } from 'mongodb';
 
 export type Client = {
   _id?: ObjectId;

package/src/talkpilot/clients/index.ts

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

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

@@ -1,16 +1,13 @@
-import {
-  createClientConfigDoc,
-  getClientConfig,
-} from "../clientsConfig.getters";
-import { createClientConfig } from "../../../test-utils/factories";
+import { createClientConfigDoc, getClientConfig } from '../clientsConfig.getters';
+import { createClientConfig } from '../../../test-utils/factories';
 
-describe("db.clientsConfig", () => {
-  describe("getClientConfig", () => {
-    it("should return client config by clientId", async () => {
-      const clientId = "test-client-id";
+describe('db.clientsConfig', () => {
+  describe('getClientConfig', () => {
+    it('should return client config by clientId', async () => {
+      const clientId = 'test-client-id';
       const clientConfig = createClientConfig({
         clientId,
-        language: "Hebrew",
+        language: 'Hebrew',
         products: { feature1: true, feature2: false } as any,
       });
 
@@ -20,25 +17,25 @@ describe("db.clientsConfig", () => {
 
       expect(result).toMatchObject({
         clientId,
-        language: "Hebrew",
+        language: 'Hebrew',
         products: { feature1: true, feature2: false },
       });
     });
 
-    it("should return null for non-existent clientId", async () => {
-      const result = await getClientConfig("non-existent-client");
+    it('should return null for non-existent clientId', async () => {
+      const result = await getClientConfig('non-existent-client');
       expect(result).toBeNull();
     });
 
-    it("should support communications config", async () => {
-      const clientId = "communications-test";
+    it('should support communications config', async () => {
+      const clientId = 'communications-test';
       const clientConfig = createClientConfig({
         clientId,
         communications: {
           sendGrid: {
-            emailTo: ["test@example.com"],
-            templateId: "temp-123",
-            senderId: "sender-123",
+            emailTo: ['test@example.com'],
+            templateId: 'temp-123',
+            senderId: 'sender-123',
           },
           sms: {},
           whatsapp: {},
@@ -53,9 +50,9 @@ describe("db.clientsConfig", () => {
         clientId,
         communications: {
           sendGrid: {
-            emailTo: ["test@example.com"],
-            templateId: "temp-123",
-            senderId: "sender-123",
+            emailTo: ['test@example.com'],
+            templateId: 'temp-123',
+            senderId: 'sender-123',
           },
           sms: {},
           whatsapp: {},

package/src/talkpilot/clientsConfig/clientsConfig.getters.ts

@@ -1,8 +1,8 @@
-import { ClientConfigDoc, getDb, findClientByPhoneNumber } from "../index";
-import { Collection } from "mongodb";
+import { ClientConfigDoc, getDb, findClientByPhoneNumber } from '../index';
+import { Collection } from 'mongodb';
 
 export const getClientsConfigCollection = (): Collection<ClientConfigDoc> => {
-  return getDb().collection<ClientConfigDoc>("clientsConfig");
+  return getDb().collection<ClientConfigDoc>('clientsConfig');
 };
 
 export const getClientConfig = (clientId: string) => {
@@ -15,8 +15,6 @@ export const getClientConfigByPhone = async (phone: string) => {
   return getClientConfig(client.clientId);
 };
 
-export const createClientConfigDoc = async (
-  clientConfig: ClientConfigDoc,
-): Promise<void> => {
+export const createClientConfigDoc = async (clientConfig: ClientConfigDoc): Promise<void> => {
   await getClientsConfigCollection().insertOne(clientConfig);
 };