@talkpilot/core-db 1.1.4 → 1.1.6

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,60 +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",
     ]);
   });
 });
-

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

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

@@ -1,139 +1,147 @@
 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"],
           },
         },
         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,17 +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';
+  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}}"). */
@@ -87,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);