@talkpilot/core-db 1.1.3 → 1.1.5

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

@@ -1,11 +1,17 @@
-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';
+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";
 
 export const getCallsCollection = () => {
-  return getDb().collection<Call>('calls');
+  return getDb().collection<Call>("calls");
 };
 
 export const getCallByCallSid = (callSid: string) => {
@@ -13,7 +19,9 @@ 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) => {
@@ -24,20 +32,22 @@ 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> => {
-  const result = await getCallsCollection().findOneAndUpdate(
+  return await getCallsCollection().findOneAndUpdate(
     { callSid: callSid },
     {
       $set: {
@@ -45,15 +55,17 @@ 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,
@@ -67,7 +79,7 @@ export const getCallsByClientAndDateRange = (clientId: string, startDate: Date,
 
 export const findCallsByQuery = async (
   query: Filter<Call>,
-  options?: CallQueryOptions
+  options?: CallQueryOptions,
 ): Promise<CallDoc[]> => {
   const cursor = getCallsCollection().find(query);
   return await applyQueryOptions(cursor, options).toArray();
@@ -124,7 +136,7 @@ export const range = {
 
 export function startOfDay(d: Date = new Date()): Date {
   const x = new Date(d);
-  x.setHours(0, 0, 0, 0);
+  x.setUTCHours(0, 0, 0, 0);
   return x;
 }
 
@@ -142,21 +154,29 @@ 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"] },
+            ],
           },
         },
       },
@@ -167,8 +187,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] } },
         },
       },
     ])
@@ -186,7 +206,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
@@ -197,22 +217,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/results.types';
+import { ObjectId, Sort, WithId } from "mongodb";
+import { TranscriptionSegment } from "../results";
 
-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,46 +4,66 @@ 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);
@@ -52,21 +72,33 @@ 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);
@@ -77,8 +109,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[] = [];
@@ -86,11 +118,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,
+        }),
       );
     }
 
@@ -101,8 +133,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[] = [];
@@ -110,17 +142,19 @@ 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,17 +1,18 @@
-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();
@@ -27,7 +28,7 @@ const insertClientAudioBuffer = async (
   };
   const clientAudioBufferMongoDocument: ClientAudioBufferType = {
     ...inputFieldsForDocument,
-    codec: 'mulaw',
+    codec: "mulaw",
     sampleRateHz: 8000,
     channels: 1,
     createdAt: realtimeDate,
@@ -39,7 +40,7 @@ const insertClientAudioBuffer = async (
 const findClientAudioBuffersByCallSidAndRange = async (
   callSid: string,
   startMs?: number,
-  endMs?: number
+  endMs?: number,
 ): Promise<ClientAudioBufferDoc[]> => {
   const collection = getClientAudioBuffersCollection();
   if (startMs === undefined) {
@@ -57,7 +58,10 @@ 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);
@@ -80,7 +84,10 @@ const getAudioChunksByCallSid = async (callSid: string, limit?: number): Promise
   });
 };
 
-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,11 +1,16 @@
-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,13 +1,16 @@
-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,
       });
 
@@ -17,25 +20,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: {},
@@ -50,9 +53,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,6 +15,8 @@ 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);
 };