@talkpilot/core-db 1.1.8 → 1.1.10

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

@@ -1,141 +1,148 @@
 export const flowMongoSchema = {
-  bsonType: 'object',
-  required: ['flowName', 'systemInstructions', 'initialSentence', 'interactions'],
+  bsonType: "object",
+  required: [
+    "flowName",
+    "systemInstructions",
+    "initialSentence",
+    "interactions",
+  ],
   properties: {
-    _id: { bsonType: 'objectId' },
-    flowName: { bsonType: 'string' },
-    clientId: { bsonType: 'string' },
-    systemInstructions: { bsonType: 'string' },
-    initialSentence: { bsonType: 'string' },
-    voice: { bsonType: ['string', 'null'] },
+    _id: { bsonType: "objectId" },
+    flowName: { bsonType: "string" },
+    clientId: { bsonType: "string" },
+    systemInstructions: { bsonType: "string" },
+    initialSentence: { bsonType: "string" },
+    voice: { bsonType: ["string", "null"] },
     conversationSettings: {
-      bsonType: ['object', 'null'],
+      bsonType: ["object", "null"],
       properties: {
         interruptions: {
-          bsonType: ['object', 'null'],
+          bsonType: ["object", "null"],
           properties: {
-            enableInterruptionDetection: { bsonType: 'bool' },
-            interruptionWindowSeconds: { bsonType: 'number' },
-            interruptionThresholdSeconds: { bsonType: 'number' },
-            interruptionInstruction: { bsonType: 'string' },
+            enableInterruptionDetection: { bsonType: "bool" },
+            interruptionWindowSeconds: { bsonType: "number" },
+            interruptionThresholdSeconds: { bsonType: "number" },
+            interruptionInstruction: { bsonType: "string" },
           },
           additionalProperties: false,
         },
         silence: {
-          bsonType: ['object', 'null'],
+          bsonType: ["object", "null"],
           properties: {
-            enableSilenceDetection: { bsonType: 'bool' },
-            firstWarningSilenceSeconds: { bsonType: 'number' },
-            firstWarningInstruction: { bsonType: 'string' },
-            secondWarningSilenceSeconds: { bsonType: 'number' },
-            secondWarningInstruction: { bsonType: 'string' },
-            disconnectSilenceSeconds: { bsonType: 'number' },
+            enableSilenceDetection: { bsonType: "bool" },
+            firstWarningSilenceSeconds: { bsonType: "number" },
+            firstWarningInstruction: { bsonType: "string" },
+            secondWarningSilenceSeconds: { bsonType: "number" },
+            secondWarningInstruction: { bsonType: "string" },
+            disconnectSilenceSeconds: { bsonType: "number" },
           },
           additionalProperties: false,
         },
-        liveTimeUpdates: { bsonType: 'bool' },
+        liveTimeUpdates: { bsonType: "bool" },
       },
       additionalProperties: false,
     },
     interactions: {
-      bsonType: 'array',
+      bsonType: "array",
       items: {
-        bsonType: 'object',
-        required: ['id', 'type', 'text', 'position'],
+        bsonType: "object",
+        required: ["id", "type", "text", "position"],
         properties: {
-          id: { bsonType: 'string' },
-          type: { bsonType: 'string' },
-          text: { bsonType: 'string' },
-          successStatus: { bsonType: ['string', 'null'] },
+          id: { bsonType: "string" },
+          type: { bsonType: "string" },
+          text: { bsonType: "string" },
+          successStatus: { bsonType: ["string", "null"] },
           conditions: {
-            bsonType: ['array', 'null'],
+            bsonType: ["array", "null"],
             items: {
-              bsonType: 'object',
-              required: ['conditionString'],
+              bsonType: "object",
+              required: ["conditionString"],
               properties: {
-                conditionString: { bsonType: 'string' },
-                nodeType: { bsonType: ['string', 'null'] },
-                id: { bsonType: ['string', 'null'] },
+                conditionString: { bsonType: "string" },
+                nodeType: { bsonType: ["string", "null"] },
+                id: { bsonType: ["string", "null"] },
               },
             },
           },
-          defaultNodeType: { bsonType: ['string', 'null'] },
+          defaultNodeType: { bsonType: ["string", "null"] },
           defaultChild: {
-            bsonType: ['object', 'null'],
-            properties: { id: { bsonType: 'string' } },
+            bsonType: ["object", "null"],
+            properties: { id: { bsonType: "string" } },
           },
           position: {
-            bsonType: 'object',
-            required: ['x', 'y'],
+            bsonType: "object",
+            required: ["x", "y"],
             properties: {
-              x: { bsonType: 'number' },
-              y: { bsonType: 'number' },
+              x: { bsonType: "number" },
+              y: { bsonType: "number" },
             },
           },
-          name: { bsonType: ['string', 'null'] },
-          children: { bsonType: ['array', 'null'], items: { bsonType: 'string' } },
-          resultsLabel: { bsonType: ['string', 'null'] },
-          resultsColor: { bsonType: ['string', 'null'] },
+          name: { bsonType: ["string", "null"] },
+          children: {
+            bsonType: ["array", "null"],
+            items: { bsonType: "string" },
+          },
+          resultsLabel: { bsonType: ["string", "null"] },
+          resultsColor: { bsonType: ["string", "null"] },
         },
       },
     },
     edges: {
-      bsonType: ['array', 'null'],
+      bsonType: ["array", "null"],
       items: {
-        bsonType: 'object',
-        required: ['id', 'source', 'target'],
+        bsonType: "object",
+        required: ["id", "source", "target"],
         properties: {
-          id: { bsonType: 'string' },
-          source: { bsonType: 'string' },
-          target: { bsonType: 'string' },
-          label: { bsonType: ['string', 'null'] },
+          id: { bsonType: "string" },
+          source: { bsonType: "string" },
+          target: { bsonType: "string" },
+          label: { bsonType: ["string", "null"] },
         },
       },
     },
     metaKeys: {
-      bsonType: ['array', 'null'],
+      bsonType: ["array", "null"],
       items: {
-        bsonType: 'object',
-        required: ['key'],
+        bsonType: "object",
+        required: ["key"],
         properties: {
-          key: { bsonType: 'string' },
-          required: { bsonType: 'bool' },
+          key: { bsonType: "string" },
+          required: { bsonType: "bool" },
         },
       },
     },
     userProperties: {
-      bsonType: ['array', 'null'],
+      bsonType: ["array", "null"],
       items: {
-        bsonType: 'object',
-        required: ['name', 'description'],
+        bsonType: "object",
+        required: ["name", "description"],
         properties: {
-          name: { bsonType: 'string' },
-          description: { bsonType: 'string' },
+          name: { bsonType: "string" },
+          description: { bsonType: "string" },
         },
       },
     },
     tools: {
-      bsonType: ['array', 'null'],
+      bsonType: ["array", "null"],
       items: {
-        bsonType: 'object',
-        required: ['id', 'name', 'url', 'method', 'parameters'],
+        bsonType: "object",
+        required: ["id", "name", "url", "method", "parameters"],
         properties: {
-          id: { bsonType: 'string' },
-          name: { bsonType: 'string' },
-          description: { bsonType: 'string' },
-          url: { bsonType: 'string' },
-          method: { bsonType: 'string' },
-          headers: { bsonType: 'object' },
-          parameters: { bsonType: 'object' },
-          bodyFormat: { bsonType: 'string', enum: ['json', 'form-data'] },
-          preventAudioDuringTool: { bsonType: 'bool' },
-          sendUserAuthToken: { bsonType: 'bool' },
-          runInBackground: { bsonType: 'bool' },
+          id: { bsonType: "string" },
+          name: { bsonType: "string" },
+          description: { bsonType: "string" },
+          url: { bsonType: "string" },
+          method: { bsonType: "string" },
+          headers: { bsonType: "object" },
+          parameters: { bsonType: "object" },
+          bodyFormat: { bsonType: "string", enum: ["json", "form-data"] },
+          preventAudioDuringTool: { bsonType: "bool" },
+          sendUserAuthToken: { bsonType: "bool" },
+          runInBackground: { bsonType: "bool" },
           backgroundToolType: {
-            bsonType: 'string',
-            enum: ['backgroundToolAlways', 'backgroundToolOnce'],
+            bsonType: "string",
+            enum: ["backgroundToolAlways", "backgroundToolOnce"],
           },
-          backgroundContinuationInstructions: { bsonType: 'string' },
         },
         additionalProperties: false,
       },

package/src/talkpilot/flows/flows.types.ts

@@ -1,12 +1,12 @@
-import { ObjectId } from 'mongodb';
+import { ObjectId } from "mongodb";
 
 /* ----------  Basic helpers  ---------- */
 
 export type Position = { x: number; y: number };
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
 
-export type QuestionType = 'open' | 'multiple' | 'table';
-export type SelectionType = 'single' | 'multiple';
+export type QuestionType = "open" | "multiple" | "table";
+export type SelectionType = "single" | "multiple";
 
 export type Question = {
   id: string;
@@ -24,14 +24,14 @@ export type Question = {
 };
 
 export type NodeKind =
-  | 'start'
-  | 'say'
-  | 'condition'
-  | 'improvise'
-  | 'tool'
-  | 'sendMessage'
-  | 'questionsList'
-  | 'end';
+  | "start"
+  | "say"
+  | "condition"
+  | "improvise"
+  | "tool"
+  | "sendMessage"
+  | "questionsList"
+  | "end";
 type BaseNode = {
   id: string;
   type: NodeKind;
@@ -44,12 +44,12 @@ type BaseNode = {
   questions?: Question[] | null;
 };
 
-export type StartNode = BaseNode & { type: 'start' };
+export type StartNode = BaseNode & { type: "start" };
 
-export type SayNode = BaseNode & { type: 'say' };
+export type SayNode = BaseNode & { type: "say" };
 
 export type ConditionNode = BaseNode & {
-  type: 'condition';
+  type: "condition";
   conditions: Array<{
     conditionString: string;
     nodeType?: string | null;
@@ -59,7 +59,7 @@ export type ConditionNode = BaseNode & {
   defaultChild?: { id?: string } | null;
 };
 
-export type ImproviseNode = BaseNode & { type: 'improvise' };
+export type ImproviseNode = BaseNode & { type: "improvise" };
 
 export type FlowTool = {
   id: string;
@@ -69,18 +69,17 @@ export type FlowTool = {
   method: HttpMethod;
   headers?: Record<string, string>;
   parameters: Record<string, unknown>;
-  bodyFormat?: 'json' | 'form-data';
+  bodyFormat?: "json" | "form-data";
   preventAudioDuringTool?: boolean;
   sendUserAuthToken?: boolean;
   runInBackground?: boolean;
-  backgroundToolType?: 'backgroundToolAlways' | 'backgroundToolOnce';
-  backgroundContinuationInstructions?: string;
+  backgroundToolType?: "backgroundToolAlways" | "backgroundToolOnce";
 };
 
-export type SendMethod = 'sms' | 'whatsapp';
+export type SendMethod = "sms" | "whatsapp";
 
 export type SendMessageNode = BaseNode & {
-  type: 'sendMessage';
+  type: "sendMessage";
   /** Which channel to use. If omitted, decide at runtime (e.g., default to whatsapp). */
   send_method: SendMethod;
   /** Destination phone (E.164 or templated string like "{{userPhone}}"). */
@@ -88,17 +87,17 @@ export type SendMessageNode = BaseNode & {
 };
 
 export type ToolNode = BaseNode & {
-  type: 'tool';
+  type: "tool";
   name: string;
   text: string;
 };
 
 export type QuestionsListNode = BaseNode & {
-  type: 'questionsList';
+  type: "questionsList";
   questions: Question[];
 };
 
-export type EndNode = BaseNode & { type: 'end' };
+export type EndNode = BaseNode & { type: "end" };
 
 export type Interaction =
   | StartNode

package/src/talkpilot/flows/index.ts

@@ -1,2 +1,2 @@
-export { getFlowsCollection, findFlowById } from './flows.getter';
-export type * from './flows.types';
+export { getFlowsCollection, findFlowById } from "./flows.getter";
+export type * from "./flows.types";

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

@@ -1,27 +1,30 @@
-import { ObjectId } from 'mongodb';
-import { faker } from '@faker-js/faker';
+import { ObjectId } from "mongodb";
+import { faker } from "@faker-js/faker";
 import {
   getGroupsCollection,
   findGroups,
   createGroup,
   updateGroup,
   removeGroup,
-} from '../groups.getters';
-import { createGroup as createGroupDoc } from '../../../test-utils/factories';
+} from "../groups.getters";
+import { createGroup as createGroupDoc } from "../../../test-utils/factories";
 
-describe('db.groups', () => {
-  describe('getGroupsCollection', () => {
+describe("db.groups", () => {
+  describe("getGroupsCollection", () => {
     it('returns the "groups" collection', () => {
-      expect(getGroupsCollection().collectionName).toBe('groups');
+      expect(getGroupsCollection().collectionName).toBe("groups");
     });
   });
 
-  describe('findGroups', () => {
-    it('returns groups matching the provided filter', async () => {
+  describe("findGroups", () => {
+    it("returns groups matching the provided filter", async () => {
       const clientId = faker.string.uuid();
-      const g1 = createGroupDoc({ clientId, name: 'Group A' });
-      const g2 = createGroupDoc({ clientId, name: 'Group B' });
-      const gOther = createGroupDoc({ clientId: faker.string.uuid(), name: 'Group C' });
+      const g1 = createGroupDoc({ clientId, name: "Group A" });
+      const g2 = createGroupDoc({ clientId, name: "Group B" });
+      const gOther = createGroupDoc({
+        clientId: faker.string.uuid(),
+        name: "Group C",
+      });
 
       await getGroupsCollection().insertMany([g1, g2, gOther]);
 
@@ -29,26 +32,29 @@ describe('db.groups', () => {
       const names = result.map((g) => g.name).sort();
 
       expect(result).toHaveLength(2);
-      expect(names).toEqual(['Group A', 'Group B']);
+      expect(names).toEqual(["Group A", "Group B"]);
     });
   });
 
-  describe('createGroup', () => {
-    it('inserts a group and returns insertedId', async () => {
-      const toInsert = createGroupDoc({ name: 'New Group' });
+  describe("createGroup", () => {
+    it("inserts a group and returns insertedId", async () => {
+      const toInsert = createGroupDoc({ name: "New Group" });
 
       const insertedId = await createGroup(toInsert);
       expect(insertedId).toBeInstanceOf(ObjectId);
 
       const fromDb = await getGroupsCollection().findOne({ _id: insertedId });
-      expect(fromDb?.name).toBe('New Group');
+      expect(fromDb?.name).toBe("New Group");
       expect(fromDb?.clientId).toBe(toInsert.clientId);
     });
   });
 
-  describe('updateGroup', () => {
-    it('updates the group and sets updatedAt, returning the updated document', async () => {
-      const original = createGroupDoc({ name: 'Before', description: 'Old desc' });
+  describe("updateGroup", () => {
+    it("updates the group and sets updatedAt, returning the updated document", async () => {
+      const original = createGroupDoc({
+        name: "Before",
+        description: "Old desc",
+      });
       const { insertedId } = await getGroupsCollection().insertOne(original);
       const before = await getGroupsCollection().findOne({ _id: insertedId });
 
@@ -57,21 +63,22 @@ describe('db.groups', () => {
 
       const res = await updateGroup(
         { _id: insertedId },
-        { name: 'After', description: 'New desc' }
+        { name: "After", description: "New desc" },
       );
 
       expect(res?._id).toEqual(insertedId);
-      expect(res?.name).toBe('After');
-      expect(res?.description).toBe('New desc');
+      expect(res?.name).toBe("After");
+      expect(res?.description).toBe("New desc");
       expect(new Date(res!.updatedAt).getTime()).toBeGreaterThan(
-        new Date(before!.updatedAt).getTime()
+        new Date(before!.updatedAt).getTime(),
       );
     });
   });
 
-  describe('removeGroup', () => {
-    it('removes a group by string id', async () => {
-      const { insertedId } = await getGroupsCollection().insertOne(createGroupDoc());
+  describe("removeGroup", () => {
+    it("removes a group by string id", async () => {
+      const { insertedId } =
+        await getGroupsCollection().insertOne(createGroupDoc());
 
       const result = await removeGroup(insertedId.toHexString());
       expect(result.deletedCount).toBe(1);

package/src/talkpilot/groups/__tests__/phone.utils.spec.ts

@@ -1,32 +1,32 @@
-import { enrichPhoneNumber, isValidE164 } from '../phone.utils';
+import { enrichPhoneNumber, isValidE164 } from "../phone.utils";
 
-describe('Phone Utilities', () => {
-  describe('enrichPhoneNumber', () => {
-    it('should enrich Israeli number', () => {
-      const result = enrichPhoneNumber('+972507725874');
-      expect(result?.e164).toBe('+972507725874');
+describe("Phone Utilities", () => {
+  describe("enrichPhoneNumber", () => {
+    it("should enrich Israeli number", () => {
+      const result = enrichPhoneNumber("+972507725874");
+      expect(result?.e164).toBe("+972507725874");
       expect(result?.region).toBeDefined();
-      expect(result?.countryCallingCode).toBe('972');
+      expect(result?.countryCallingCode).toBe("972");
     });
 
-    it('should enrich US number', () => {
-      const result = enrichPhoneNumber('+12025551234');
-      expect(result?.region).toBe('US');
-      expect(result?.countryCallingCode).toBe('1');
+    it("should enrich US number", () => {
+      const result = enrichPhoneNumber("+12025551234");
+      expect(result?.region).toBe("US");
+      expect(result?.countryCallingCode).toBe("1");
     });
 
-    it('should return null for invalid', () => {
-      expect(enrichPhoneNumber('invalid')).toBeNull();
-      expect(enrichPhoneNumber('0507725874')).toBeNull();
+    it("should return null for invalid", () => {
+      expect(enrichPhoneNumber("invalid")).toBeNull();
+      expect(enrichPhoneNumber("0507725874")).toBeNull();
     });
   });
 
-  describe('isValidE164', () => {
-    it('should validate E.164 format', () => {
-      expect(isValidE164('+972508832983')).toBe(true);
-      expect(isValidE164('+12025551234')).toBe(true);
-      expect(isValidE164('0501234567')).toBe(false);
-      expect(isValidE164('invalid')).toBe(false);
+  describe("isValidE164", () => {
+    it("should validate E.164 format", () => {
+      expect(isValidE164("+972508832983")).toBe(true);
+      expect(isValidE164("+12025551234")).toBe(true);
+      expect(isValidE164("0501234567")).toBe(false);
+      expect(isValidE164("invalid")).toBe(false);
     });
   });
 });

package/src/talkpilot/groups/groups.getters.ts

@@ -1,8 +1,8 @@
-import { getDb, ObjectId, Group } from '../index';
-import { Collection, Filter } from 'mongodb';
+import { getDb, ObjectId, Group } from "../index";
+import { Collection, Filter } from "mongodb";
 
 export const getGroupsCollection = (): Collection<Group> => {
-  return getDb().collection<Group>('groups');
+  return getDb().collection<Group>("groups");
 };
 
 export const findGroups = async (filter: Filter<Group>): Promise<Group[]> => {
@@ -14,11 +14,14 @@ export const createGroup = async (group: Group) => {
   return insertedId;
 };
 
-export const updateGroup = async (filter: Filter<Group>, data: Partial<Group>) => {
+export const updateGroup = async (
+  filter: Filter<Group>,
+  data: Partial<Group>,
+) => {
   return await getGroupsCollection().findOneAndUpdate(
     filter,
     { $set: { ...data, updatedAt: new Date() } },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
 };
 

package/src/talkpilot/groups/groups.types.ts

@@ -1,4 +1,4 @@
-import { WithId } from 'mongodb';
+import { WithId } from "mongodb";
 export type E164 = `+${string}`;
 export type CountryISO = Uppercase<string>;
 

package/src/talkpilot/groups/index.ts

@@ -1,3 +1,3 @@
-export * from './groups.getters';
-export * from './groups.types';
-export * from './phone.utils';
+export * from "./groups.getters";
+export * from "./groups.types";
+export * from "./phone.utils";

package/src/talkpilot/groups/phone.utils.ts

@@ -1,21 +1,27 @@
-import { PhoneNumberUtil, PhoneNumberFormat } from 'google-libphonenumber';
-import type { Phone, E164, CountryISO } from './groups.types';
+import { PhoneNumberUtil, PhoneNumberFormat } from "google-libphonenumber";
+import type { Phone, E164, CountryISO } from "./groups.types";
 
 const phoneUtil = PhoneNumberUtil.getInstance();
 
 export const enrichPhoneNumber = (e164: string): Phone | null => {
   try {
-    const phoneNumber = phoneUtil.parse(e164, 'ZZ');
+    const phoneNumber = phoneUtil.parse(e164, "ZZ");
     if (!phoneUtil.isValidNumber(phoneNumber)) {
       return null;
     }
 
-    const normalizedE164 = phoneUtil.format(phoneNumber, PhoneNumberFormat.E164) as E164;
+    const normalizedE164 = phoneUtil.format(
+      phoneNumber,
+      PhoneNumberFormat.E164,
+    ) as E164;
     const region = phoneUtil.getRegionCodeForNumber(phoneNumber) as CountryISO;
     const countryCallingCode = phoneNumber.getCountryCode()?.toString();
     const national = phoneNumber.getNationalNumber()?.toString();
     const ext = phoneNumber.getExtension() || undefined;
-    const formatted = phoneUtil.format(phoneNumber, PhoneNumberFormat.INTERNATIONAL);
+    const formatted = phoneUtil.format(
+      phoneNumber,
+      PhoneNumberFormat.INTERNATIONAL,
+    );
 
     return {
       e164: normalizedE164,
@@ -32,7 +38,7 @@ export const enrichPhoneNumber = (e164: string): Phone | null => {
 
 export const isValidE164 = (e164: string): boolean => {
   try {
-    const phoneNumber = phoneUtil.parse(e164, 'ZZ');
+    const phoneNumber = phoneUtil.parse(e164, "ZZ");
     return phoneUtil.isValidNumber(phoneNumber);
   } catch (error) {
     return false;

package/src/talkpilot/index.ts

@@ -1,27 +1,27 @@
-import { Db, ObjectId as MongoObjectId } from 'mongodb';
+import { Db, ObjectId as MongoObjectId } from "mongodb";
 
-export * from './flows';
-export * from './results';
-export * from './sessions';
-export * from './phone_numbers';
-export * from './leads';
-export * from './clients';
-export * from './agents';
-export * from './plans';
-export * from './subscriptions';
-export * from './groups';
-export * from './calls';
-export * from './clientAudioBuffers';
-export * from './clientsConfig';
-export * from './backgroundToolResults';
-export { mongodbClient } from './mongodb-client';
+export * from "./flows";
+export * from "./results";
+export * from "./sessions";
+export * from "./phone_numbers";
+export * from "./leads";
+export * from "./clients";
+export * from "./agents";
+export * from "./plans";
+export * from "./subscriptions";
+export * from "./groups";
+export * from "./calls";
+export * from "./clientAudioBuffers";
+export * from "./clientsConfig";
+export * from "./backgroundToolResults";
+export { mongodbClient } from "./mongodb-client";
 
 let db: Db;
 export const setDb = (d: Db) => {
   db = d;
 };
 export const getDb = (): Db => {
-  if (!db) throw new Error('DB not initialised');
+  if (!db) throw new Error("DB not initialised");
   return db;
 };