@talkpilot/core-db 1.1.8 → 1.1.10

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);
 };

package/src/talkpilot/clientsConfig/clientsConfig.types.ts

@@ -1,4 +1,4 @@
-import { WithId } from 'mongodb';
+import { WithId } from "mongodb";
 
 export type InitiateCallForShortSlaConfig = {
   active: boolean;
@@ -35,16 +35,16 @@ export type Products = {
 export type ClinicsProduct = {
   api_key_secret_name: string;
   base_api_url: string;
-  provider: 'clinix' | (string & {});
+  provider: "clinix" | (string & {});
   description?: string;
 };
 
 export type ClientLanguageName =
-  | 'Hebrew'
-  | 'English'
-  | 'Russian'
-  | 'French'
-  | 'Spanish'
+  | "Hebrew"
+  | "English"
+  | "Russian"
+  | "French"
+  | "Spanish"
   | (string & {});
 
 export type SendGridConfig = {
@@ -72,4 +72,6 @@ export type ClientConfig<P extends Products = Products> = {
   communications?: CommunicationsConfig;
 };
 
-export type ClientConfigDoc<P extends Products = Products> = WithId<ClientConfig<P>>;
+export type ClientConfigDoc<P extends Products = Products> = WithId<
+  ClientConfig<P>
+>;

package/src/talkpilot/clientsConfig/index.ts

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

package/src/talkpilot/flows/__tests__/flows.schema.spec.ts

@@ -1,63 +1,64 @@
-import { flowMongoSchema } from '../flows.schema';
+import { flowMongoSchema } from "../flows.schema";
 
-describe('flowMongoSchema', () => {
-  it('defines conversationSettings as optional object or null', () => {
+describe("flowMongoSchema", () => {
+  it("defines conversationSettings as optional object or null", () => {
     const schema: any = flowMongoSchema;
 
-    expect(schema.properties).toHaveProperty('conversationSettings');
-    expect(schema.properties.conversationSettings.bsonType).toEqual(['object', 'null']);
-    expect(schema.required).not.toContain('conversationSettings');
+    expect(schema.properties).toHaveProperty("conversationSettings");
+    expect(schema.properties.conversationSettings.bsonType).toEqual([
+      "object",
+      "null",
+    ]);
+    expect(schema.required).not.toContain("conversationSettings");
     expect(schema.additionalProperties).toBe(false);
   });
 
-  it('defines conversationSettings with expected nested properties', () => {
+  it("defines conversationSettings with expected nested properties", () => {
     const schema: any = flowMongoSchema;
     const convSettings = schema.properties.conversationSettings.properties;
 
-    expect(convSettings).toHaveProperty('interruptions');
-    expect(convSettings.interruptions.bsonType).toEqual(['object', 'null']);
+    expect(convSettings).toHaveProperty("interruptions");
+    expect(convSettings.interruptions.bsonType).toEqual(["object", "null"]);
 
     const interruptions = convSettings.interruptions.properties;
-    expect(interruptions.enableInterruptionDetection.bsonType).toEqual('bool');
-    expect(interruptions.interruptionWindowSeconds.bsonType).toEqual('number');
-    expect(interruptions.interruptionThresholdSeconds.bsonType).toEqual('number');
-    expect(interruptions.interruptionInstruction.bsonType).toEqual('string');
+    expect(interruptions.enableInterruptionDetection.bsonType).toEqual("bool");
+    expect(interruptions.interruptionWindowSeconds.bsonType).toEqual("number");
+    expect(interruptions.interruptionThresholdSeconds.bsonType).toEqual(
+      "number",
+    );
+    expect(interruptions.interruptionInstruction.bsonType).toEqual("string");
 
-    expect(convSettings).toHaveProperty('silence');
-    expect(convSettings.silence.bsonType).toEqual(['object', 'null']);
+    expect(convSettings).toHaveProperty("silence");
+    expect(convSettings.silence.bsonType).toEqual(["object", "null"]);
 
     const silence = convSettings.silence.properties;
-    expect(silence.enableSilenceDetection.bsonType).toEqual('bool');
-    expect(silence.firstWarningSilenceSeconds.bsonType).toEqual('number');
-    expect(silence.firstWarningInstruction.bsonType).toEqual('string');
-    expect(silence.secondWarningSilenceSeconds.bsonType).toEqual('number');
-    expect(silence.secondWarningInstruction.bsonType).toEqual('string');
-    expect(silence.disconnectSilenceSeconds.bsonType).toEqual('number');
-    expect(convSettings).toHaveProperty('liveTimeUpdates');
-    expect(convSettings.liveTimeUpdates.bsonType).toEqual('bool');
+    expect(silence.enableSilenceDetection.bsonType).toEqual("bool");
+    expect(silence.firstWarningSilenceSeconds.bsonType).toEqual("number");
+    expect(silence.firstWarningInstruction.bsonType).toEqual("string");
+    expect(silence.secondWarningSilenceSeconds.bsonType).toEqual("number");
+    expect(silence.secondWarningInstruction.bsonType).toEqual("string");
+    expect(silence.disconnectSilenceSeconds.bsonType).toEqual("number");
+    expect(convSettings).toHaveProperty("liveTimeUpdates");
+    expect(convSettings.liveTimeUpdates.bsonType).toEqual("bool");
   });
 
-  it('should define tools schema and return a backgroundToolType enum with allowed values', () => {
+  it("should define tools schema and return a backgroundToolType enum with allowed values", () => {
     const schema: any = flowMongoSchema;
 
-    expect(schema.properties).toHaveProperty('tools');
-    expect(schema.properties.tools.bsonType).toEqual(['array', 'null']);
+    expect(schema.properties).toHaveProperty("tools");
+    expect(schema.properties.tools.bsonType).toEqual(["array", "null"]);
 
     const toolItem = schema.properties.tools.items;
-    expect(toolItem.bsonType).toBe('object');
+    expect(toolItem.bsonType).toBe("object");
 
-    expect(toolItem.properties).toHaveProperty('runInBackground');
-    expect(toolItem.properties.runInBackground.bsonType).toBe('bool');
+    expect(toolItem.properties).toHaveProperty("runInBackground");
+    expect(toolItem.properties.runInBackground.bsonType).toBe("bool");
 
-    expect(toolItem.properties).toHaveProperty('backgroundToolType');
-    expect(toolItem.properties.backgroundToolType.bsonType).toBe('string');
+    expect(toolItem.properties).toHaveProperty("backgroundToolType");
+    expect(toolItem.properties.backgroundToolType.bsonType).toBe("string");
     expect(toolItem.properties.backgroundToolType.enum).toEqual([
-      'backgroundToolAlways',
-      'backgroundToolOnce',
+      "backgroundToolAlways",
+      "backgroundToolOnce",
     ]);
-
-    expect(toolItem.properties).toHaveProperty('backgroundContinuationInstructions');
-    expect(toolItem.properties.backgroundContinuationInstructions.bsonType).toBe('string');
   });
 });
-

package/src/talkpilot/flows/flows.getter.ts

@@ -1,11 +1,14 @@
-import type { Collection, ObjectId, WithId } from 'mongodb';
-import { getDb } from '../index';
-import type { Flow } from './flows.types';
+import type { Collection, ObjectId, WithId } from "mongodb";
+import { getDb } from "../index";
+import type { Flow } from "./flows.types";
 
 export const getFlowsCollection = (): Collection<Flow> => {
-  return getDb().collection<Flow>('flows');
+  return getDb().collection<Flow>("flows");
 };
 
-export const findFlowById = (flowId: ObjectId, clientId: string): Promise<WithId<Flow> | null> => {
+export const findFlowById = (
+  flowId: ObjectId,
+  clientId: string,
+): Promise<WithId<Flow> | null> => {
   return getFlowsCollection().findOne({ _id: flowId, clientId });
 };