@talkpilot/core-db 1.1.3 → 1.1.5

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

@@ -1,39 +1,52 @@
-import { findSessionOfIncomingCall, getSessionsCollection } from '../sessions.getter';
-import { getFlowsCollection } from '../../flows/flows.getter';
-import { getPhoneNumbersCollection } from '../../phone_numbers/phone_numbers.getter';
-import { createFlow, createPhoneNumber, createSession } from '../../../test-utils/factories';
-import { faker } from '@faker-js/faker';
-import { ObjectId } from 'mongodb';
-
-describe('sessions', () => {
-  describe('findSessionOfIncomingCall()', () => {
-    it('returns session by incoming phone number', async () => {
-      const to = '+972500000000';
-      const from = '+972540000000';
+import {
+  findSessionOfIncomingCall,
+  getSessionsCollection,
+} from "../sessions.getter";
+import { getFlowsCollection } from "../../flows";
+import { getPhoneNumbersCollection } from "../../phone_numbers";
+import {
+  createFlow,
+  createPhoneNumber,
+  createSession,
+} from "../../../test-utils/factories";
+import { faker } from "@faker-js/faker";
+import { ObjectId } from "mongodb";
+
+describe("sessions", () => {
+  describe("findSessionOfIncomingCall()", () => {
+    it("returns session by incoming phone number", async () => {
+      const to = "+972500000000";
+      const from = "+972540000000";
       const flow = createFlow({
         conversationSettings: {
           interruptions: {
             enableInterruptionDetection: true,
             interruptionWindowSeconds: 60,
             interruptionThresholdSeconds: 10,
-            interruptionInstruction: 'I am hearing background noise that makes it hard for me to focus on what you are saying. Please try to move to a quieter place or reduce the noise so I can better assist you.',
+            interruptionInstruction:
+              "I am hearing background noise that makes it hard for me to focus on what you are saying. Please try to move to a quieter place or reduce the noise so I can better assist you.",
           },
           silence: {
             enableSilenceDetection: true,
             firstWarningSilenceSeconds: 5,
-            firstWarningInstruction: 'I have not heard you for a few seconds. If you are still on the line, please say something so we can continue.',
+            firstWarningInstruction:
+              "I have not heard you for a few seconds. If you are still on the line, please say something so we can continue.",
             secondWarningSilenceSeconds: 10,
-            secondWarningInstruction: 'I still have not heard anything from you. If you do not respond in the next few seconds, I will have to end this call.',
+            secondWarningInstruction:
+              "I still have not heard anything from you. If you do not respond in the next few seconds, I will have to end this call.",
             disconnectSilenceSeconds: 30,
           },
         },
       });
-      const phoneNumberData = createPhoneNumber({ phone_number: to, flow_id: flow._id });
+      const phoneNumberData = createPhoneNumber({
+        phone_number: to,
+        flow_id: flow._id,
+      });
       const json = { [faker.lorem.word()]: faker.lorem.sentence() };
 
       const session = createSession({
         flow_id: flow._id,
-        phone_numbers: [{ phoneNumber: from, gender: 'male', name: 'yakov' }],
+        phone_numbers: [{ phoneNumber: from, gender: "male", name: "yakov" }],
         json,
       });
 
@@ -47,15 +60,20 @@ describe('sessions', () => {
       expect(result?.flow_id).toEqual(flow._id);
     });
 
-    it('works with different phone number formats (with/without plus)', async () => {
-      const toInDB = '972500000000';
-      const fromInDB = '+972540000000';
+    it("works with different phone number formats (with/without plus)", async () => {
+      const toInDB = "972500000000";
+      const fromInDB = "+972540000000";
       const flow = createFlow();
-      const phoneNumberData = createPhoneNumber({ phone_number: toInDB, flow_id: flow._id });
+      const phoneNumberData = createPhoneNumber({
+        phone_number: toInDB,
+        flow_id: flow._id,
+      });
 
       const session = createSession({
         flow_id: flow._id,
-        phone_numbers: [{ phoneNumber: fromInDB, gender: 'female', name: 'sara' }],
+        phone_numbers: [
+          { phoneNumber: fromInDB, gender: "female", name: "sara" },
+        ],
       });
 
       await getFlowsCollection().insertOne(flow);
@@ -63,25 +81,28 @@ describe('sessions', () => {
       await getSessionsCollection().insertOne(session);
 
       // Search with from WITH plus (matches + in DB), to WITH plus (matches without + in DB)
-      const result = await findSessionOfIncomingCall('+972540000000', '+972500000000');
+      const result = await findSessionOfIncomingCall(
+        "+972540000000",
+        "+972500000000",
+      );
       expect(result).not.toBeNull();
       expect(result?.phone_numbers[0].phoneNumber).toEqual(fromInDB);
     });
 
-    it('works when flow_id is string in phone_numbers and ObjectId in session', async () => {
-      const to = '+972501111111';
-      const from = '+972541111111';
+    it("works when flow_id is string in phone_numbers and ObjectId in session", async () => {
+      const to = "+972501111111";
+      const from = "+972541111111";
       const flowId = new ObjectId();
-      
+
       // Store flow_id as string in phone_numbers
-      const phoneNumberData = createPhoneNumber({ 
-        phone_number: to, 
-        flow_id: flowId.toHexString() as any 
+      const phoneNumberData = createPhoneNumber({
+        phone_number: to,
+        flow_id: flowId.toHexString() as any,
       });
 
       const session = createSession({
         flow_id: flowId, // stored as ObjectId
-        phone_numbers: [{ phoneNumber: from, gender: 'male', name: 'isaac' }],
+        phone_numbers: [{ phoneNumber: from, gender: "male", name: "isaac" }],
       });
 
       await getPhoneNumbersCollection().insertOne(phoneNumberData);
@@ -92,19 +113,19 @@ describe('sessions', () => {
       expect(result?.flow_id?.toString()).toEqual(flowId.toHexString());
     });
 
-    it('works when flow_id is string in session', async () => {
-      const to = '+972502222222';
-      const from = '+972542222222';
+    it("works when flow_id is string in session", async () => {
+      const to = "+972502222222";
+      const from = "+972542222222";
       const flowId = new ObjectId();
-      
-      const phoneNumberData = createPhoneNumber({ 
-        phone_number: to, 
-        flow_id: flowId 
+
+      const phoneNumberData = createPhoneNumber({
+        phone_number: to,
+        flow_id: flowId,
       });
 
       const session = createSession({
         flow_id: flowId.toHexString(), // stored as string
-        phone_numbers: [{ phoneNumber: from, gender: 'female', name: 'rivka' }],
+        phone_numbers: [{ phoneNumber: from, gender: "female", name: "rivka" }],
       });
 
       await getPhoneNumbersCollection().insertOne(phoneNumberData);
@@ -115,8 +136,11 @@ describe('sessions', () => {
       expect(result?.flow_id).toEqual(flowId.toHexString());
     });
 
-    it('returns null if receiver phone number is not found', async () => {
-      const result = await findSessionOfIncomingCall('any-from', 'non-existent-to');
+    it("returns null if receiver phone number is not found", async () => {
+      const result = await findSessionOfIncomingCall(
+        "any-from",
+        "non-existent-to",
+      );
       expect(result).toBeNull();
     });
   });

package/src/talkpilot/sessions/index.ts

@@ -1,2 +1,2 @@
-export * from './sessions.getter';
-export * from './sessions.types';
+export * from "./sessions.getter";
+export * from "./sessions.types";

package/src/talkpilot/sessions/sessions.getter.ts

@@ -1,20 +1,22 @@
-import { ObjectId } from 'mongodb';
-import type { Collection, WithId } from 'mongodb';
-import { getDb, getPhoneNumbersCollection } from '../index';
-import type { Session } from './sessions.types';
+import { ObjectId } from "mongodb";
+import type { Collection, WithId } from "mongodb";
+import { getDb, getPhoneNumbersCollection } from "../index";
+import type { Session } from "./sessions.types";
 
 export const getSessionsCollection = (): Collection<Session> =>
-  getDb().collection<Session>('sessions');
+  getDb().collection<Session>("sessions");
 
 const buildPhoneCandidates = (phone: string): string[] => {
-  const raw = (phone ?? '').trim();
+  const raw = (phone ?? "").trim();
   if (!raw) return [];
 
-  const noPlus = raw.startsWith('+') ? raw.slice(1) : raw;
-  const digitsOnly = raw.replace(/\D/g, '');
-  const digitsOnlyNoPlus = noPlus.replace(/\D/g, '');
+  const noPlus = raw.startsWith("+") ? raw.slice(1) : raw;
+  const digitsOnly = raw.replace(/\D/g, "");
+  const digitsOnlyNoPlus = noPlus.replace(/\D/g, "");
 
-  return Array.from(new Set([raw, noPlus, digitsOnly, digitsOnlyNoPlus].filter(Boolean)));
+  return Array.from(
+    new Set([raw, noPlus, digitsOnly, digitsOnlyNoPlus].filter(Boolean)),
+  );
 };
 
 const buildFlowIdCandidates = (flowId: unknown): Array<string | ObjectId> => {
@@ -36,9 +38,12 @@ const buildFlowIdCandidates = (flowId: unknown): Array<string | ObjectId> => {
 
 export const findSessionById = (
   sessionId: ObjectId,
-  clientId: string
+  clientId: string,
 ): Promise<WithId<Session> | null> => {
-  return getSessionsCollection().findOne({ _id: sessionId, clientId: clientId });
+  return getSessionsCollection().findOne({
+    _id: sessionId,
+    clientId: clientId,
+  });
 };
 
 export const findSessionOfIncomingCall = async (from: string, to: string) => {
@@ -68,9 +73,9 @@ export const findSessionOfIncomingCall = async (from: string, to: string) => {
         $addFields: {
           phone_numbers: {
             $filter: {
-              input: '$phone_numbers',
-              as: 'pn',
-              cond: { $in: ['$$pn.phoneNumber', fromCandidates] },
+              input: "$phone_numbers",
+              as: "pn",
+              cond: { $in: ["$$pn.phoneNumber", fromCandidates] },
             },
           },
         },
@@ -80,7 +85,7 @@ export const findSessionOfIncomingCall = async (from: string, to: string) => {
     .toArray();
 
   if (!session) {
-    console.info('No session found for incoming call');
+    console.info("No session found for incoming call");
     return null;
   }
   return session;

package/src/talkpilot/sessions/sessions.schema.ts

@@ -1,34 +1,34 @@
 export const sessionMongoSchema = {
-  bsonType: 'object',
-  required: ['session_name'],
+  bsonType: "object",
+  required: ["session_name"],
   properties: {
-    _id: { bsonType: 'objectId' },
-    session_name: { bsonType: 'string' },
-    company_name: { bsonType: ['string', 'null'] },
-    flow_id: { bsonType: ['objectId', 'string', 'null'] },
+    _id: { bsonType: "objectId" },
+    session_name: { bsonType: "string" },
+    company_name: { bsonType: ["string", "null"] },
+    flow_id: { bsonType: ["objectId", "string", "null"] },
     metaKeys: {
-      bsonType: ['array', 'null'],
+      bsonType: ["array", "null"],
       items: {
-        bsonType: 'object',
-        required: ['key'],
+        bsonType: "object",
+        required: ["key"],
         properties: {
-          key: { bsonType: 'string' },
-          value: { bsonType: 'string' },
+          key: { bsonType: "string" },
+          value: { bsonType: "string" },
         },
       },
     },
     phone_numbers: {
-      bsonType: 'array',
+      bsonType: "array",
       items: {
-        bsonType: 'object',
-        required: ['name', 'phoneNumber'],
+        bsonType: "object",
+        required: ["name", "phoneNumber"],
         properties: {
-          name: { bsonType: 'string' },
-          phoneNumber: { bsonType: 'string' },
+          name: { bsonType: "string" },
+          phoneNumber: { bsonType: "string" },
         },
       },
     },
-    voice: { bsonType: ['string', 'null'] },
+    voice: { bsonType: ["string", "null"] },
   },
   additionalProperties: false,
 } as const;

package/src/talkpilot/sessions/sessions.types.ts

@@ -1,4 +1,4 @@
-import { ObjectId } from 'mongodb';
+import { ObjectId } from "mongodb";
 
 export type Session = {
   _id?: ObjectId;
@@ -16,7 +16,7 @@ export type Session = {
   phone_numbers: Array<{
     name: string;
     phoneNumber: string;
-    gender: 'male' | 'female';
+    gender: "male" | "female";
   }>;
 
   voice?: string | null;

package/src/talkpilot/subscriptions/__tests__/subscriptions.getters.utils.spec.ts

@@ -1,37 +1,40 @@
-import { ObjectId } from 'mongodb';
-import { buildSimpleQuery, buildDateRangeFilter } from '../subscriptions.getters.utils';
-import { SimpleSubscriptionFilter } from '../subscriptions.types';
+import { ObjectId } from "mongodb";
+import {
+  buildSimpleQuery,
+  buildDateRangeFilter,
+} from "../subscriptions.getters.utils";
+import { SimpleSubscriptionFilter } from "../subscriptions.types";
 
-describe('subscriptions.getters.utils', () => {
-  describe('buildSimpleQuery', () => {
-    it('returns empty query when filter is empty', () => {
+describe("subscriptions.getters.utils", () => {
+  describe("buildSimpleQuery", () => {
+    it("returns empty query when filter is empty", () => {
       const filter: SimpleSubscriptionFilter = {};
       const result = buildSimpleQuery(filter);
       expect(result).toEqual({});
     });
 
-    it('converts _id string to ObjectId', () => {
-      const id = '507f1f77bcf86cd799439011';
+    it("converts _id string to ObjectId", () => {
+      const id = "507f1f77bcf86cd799439011";
       const filter: SimpleSubscriptionFilter = { _id: id };
       const result = buildSimpleQuery(filter);
       expect(result._id).toBeInstanceOf(ObjectId);
       expect((result._id as ObjectId).toHexString()).toBe(id);
     });
 
-    it('includes valid simple fields', () => {
+    it("includes valid simple fields", () => {
       const filter: SimpleSubscriptionFilter = {
-        clientId: 'abc',
+        clientId: "abc",
         isActive: true,
       };
       const result = buildSimpleQuery(filter);
-      expect(result).toEqual({ clientId: 'abc', isActive: true });
+      expect(result).toEqual({ clientId: "abc", isActive: true });
     });
   });
 
-  describe('buildDateRangeFilter', () => {
-    it('returns a mongo date range filter', () => {
-      const from = new Date('2023-01-01');
-      const to = new Date('2023-01-02');
+  describe("buildDateRangeFilter", () => {
+    it("returns a mongo date range filter", () => {
+      const from = new Date("2023-01-01");
+      const to = new Date("2023-01-02");
       const result = buildDateRangeFilter(from, to);
       expect(result).toEqual({
         $gte: from,

package/src/talkpilot/subscriptions/index.ts

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

package/src/talkpilot/subscriptions/subscriptions.getters.ts

@@ -1,17 +1,17 @@
-import {getDb} from '../index';
+import { getDb } from "../index";
 import {
   SimpleSubscriptionFilter,
   Subscription,
   SubscriptionDoc,
   SubscriptionFilter,
   SubscriptionQueryOptions,
-} from './subscriptions.types';
-import {Filter, ObjectId} from 'mongodb';
-import {buildSimpleQuery} from './subscriptions.getters.utils';
-import {applyQueryOptions} from '../utils/query.utils';
+} from "./subscriptions.types";
+import { Filter, ObjectId } from "mongodb";
+import { buildSimpleQuery } from "./subscriptions.getters.utils";
+import { applyQueryOptions } from "../utils/query.utils";
 
 export const getSubscriptionsCollection = () => {
-  return getDb().collection<Subscription>('subscriptions');
+  return getDb().collection<Subscription>("subscriptions");
 };
 
 /**
@@ -20,7 +20,7 @@ export const getSubscriptionsCollection = () => {
 
 export const findSubscriptions = async (
   filter?: SubscriptionFilter,
-  options?: SubscriptionQueryOptions
+  options?: SubscriptionQueryOptions,
 ): Promise<SubscriptionDoc[]> => {
   let query: Filter<Subscription> = {};
 
@@ -51,12 +51,14 @@ export const findSubscriptions = async (
   return await applyQueryOptions(cursor, options).toArray();
 };
 
-export const countSubscriptions = async (query: Filter<Subscription>): Promise<number> => {
+export const countSubscriptions = async (
+  query: Filter<Subscription>,
+): Promise<number> => {
   return getSubscriptionsCollection().countDocuments(query);
 };
 
 export const createSubscriptionDoc = async (
-  subscriptionData: Omit<Subscription, 'createdAt' | 'updatedAt'>
+  subscriptionData: Omit<Subscription, "createdAt" | "updatedAt">,
 ): Promise<SubscriptionDoc> => {
   const now = new Date();
   const result = await getSubscriptionsCollection().insertOne({
@@ -66,13 +68,14 @@ export const createSubscriptionDoc = async (
   });
 
   const subscriptions = await findSubscriptions({ _id: result.insertedId });
-  if (!subscriptions[0]) throw new Error('Failed to retrieve created subscription');
+  if (!subscriptions[0])
+    throw new Error("Failed to retrieve created subscription");
   return subscriptions[0];
 };
 
 export const updateSubscriptionDoc = async (
   subscriptionId: ObjectId,
-  updates: Partial<Subscription>
+  updates: Partial<Subscription>,
 ): Promise<SubscriptionDoc | null> => {
   return await getSubscriptionsCollection().findOneAndUpdate(
     { _id: subscriptionId },
@@ -83,61 +86,61 @@ export const updateSubscriptionDoc = async (
       },
     },
     {
-      returnDocument: 'after',
-    }
+      returnDocument: "after",
+    },
   );
 };
 
 export const incrementSubscriptionUsage = async (
   subscriptionId: ObjectId,
-  amount: number = 1
+  amount: number = 1,
 ): Promise<SubscriptionDoc | null> => {
-  const fieldToIncrement = 'cycles.$[activeCycle].usage.usedCalls';
+  const fieldToIncrement = "cycles.$[activeCycle].usage.usedCalls";
   return await getSubscriptionsCollection().findOneAndUpdate(
-    { _id: subscriptionId, 'cycles.isActive': true },
+    { _id: subscriptionId, "cycles.isActive": true },
     {
       $inc: { [fieldToIncrement]: amount },
       $set: { updatedAt: new Date() },
     },
     {
-      arrayFilters: [{ 'activeCycle.isActive': true }],
-      returnDocument: 'after',
-    }
+      arrayFilters: [{ "activeCycle.isActive": true }],
+      returnDocument: "after",
+    },
   );
 };
 
 export const deactivateCurrentSubscriptionCycle = async (
   subscriptionId: ObjectId,
-  nextRenewalDate: Date
+  nextRenewalDate: Date,
 ): Promise<void> => {
   await getSubscriptionsCollection().updateOne(
-    { _id: subscriptionId, 'cycles.isActive': true },
+    { _id: subscriptionId, "cycles.isActive": true },
     {
       $set: {
-        'cycles.$[activeCycle].isActive': false,
+        "cycles.$[activeCycle].isActive": false,
         nextRenewalDate: nextRenewalDate,
         updatedAt: new Date(),
       },
     },
     {
-      arrayFilters: [{ 'activeCycle.isActive': true }],
-    }
+      arrayFilters: [{ "activeCycle.isActive": true }],
+    },
   );
 };
 
 export const pushNewSubscriptionCycle = async (
   subscriptionId: ObjectId,
-  newCycle: Subscription['cycles'][number]
+  newCycle: Subscription["cycles"][number],
 ): Promise<SubscriptionDoc | null> => {
   return await getSubscriptionsCollection().findOneAndUpdate(
-      {_id: subscriptionId},
-      {
-        $push: {
-          cycles: newCycle,
-        },
+    { _id: subscriptionId },
+    {
+      $push: {
+        cycles: newCycle,
       },
-      {
-        returnDocument: 'after',
-      }
+    },
+    {
+      returnDocument: "after",
+    },
   );
 };

package/src/talkpilot/subscriptions/subscriptions.getters.utils.ts

@@ -1,7 +1,14 @@
-import { ObjectId, Filter } from 'mongodb';
-import { Subscription, SimpleSubscriptionFilter, simpleFields, SimpleField } from '../index';
+import { ObjectId, Filter } from "mongodb";
+import {
+  Subscription,
+  SimpleSubscriptionFilter,
+  simpleFields,
+  SimpleField,
+} from "../index";
 
-export const buildSimpleQuery = (filter: SimpleSubscriptionFilter): Filter<Subscription> => {
+export const buildSimpleQuery = (
+  filter: SimpleSubscriptionFilter,
+): Filter<Subscription> => {
   const query: Filter<Subscription> = {};
 
   if (filter._id) {

package/src/talkpilot/subscriptions/subscriptions.types.ts

@@ -1,5 +1,5 @@
-import { Filter, ObjectId, WithId, Sort } from 'mongodb';
-import { PlanDoc } from '../plans/plans.types';
+import { Filter, ObjectId, WithId, Sort } from "mongodb";
+import { PlanDoc } from "../plans";
 
 export type SubscriptionCycle = {
   usage: {
@@ -29,13 +29,13 @@ export type Subscriptions = SubscriptionDoc[];
 
 // Define which Subscription fields we allow in a simple filter
 export const simpleFields = [
-  'clientId',
-  'planId',
-  'startDate',
-  'endDate',
-  'isActive',
-  'createdAt',
-  'nextRenewalDate',
+  "clientId",
+  "planId",
+  "startDate",
+  "endDate",
+  "isActive",
+  "createdAt",
+  "nextRenewalDate",
 ] as const;
 export type SimpleField = (typeof simpleFields)[number];
 

package/src/talkpilot/utils/__tests__/query.utils.spec.ts

@@ -1,7 +1,7 @@
-import { applyQueryOptions } from '../query.utils';
+import { applyQueryOptions } from "../query.utils";
 
-describe('query.utils', () => {
-  describe('applyQueryOptions()', () => {
+describe("query.utils", () => {
+  describe("applyQueryOptions()", () => {
     let mockCursor: any;
 
     beforeEach(() => {
@@ -12,13 +12,13 @@ describe('query.utils', () => {
       };
     });
 
-    it('should return cursor if no options provided', () => {
+    it("should return cursor if no options provided", () => {
       const result = applyQueryOptions(mockCursor);
       expect(result).toBe(mockCursor);
       expect(mockCursor.sort).not.toHaveBeenCalled();
     });
 
-    it('should apply sort, skip, and limit', () => {
+    it("should apply sort, skip, and limit", () => {
       const options = {
         sort: { name: 1 },
         skip: 10,
@@ -26,20 +26,20 @@ describe('query.utils', () => {
       };
 
       const result = applyQueryOptions(mockCursor, options);
-      
+
       expect(result).toBe(mockCursor);
       expect(mockCursor.sort).toHaveBeenCalledWith({ name: 1 });
       expect(mockCursor.skip).toHaveBeenCalledWith(10);
       expect(mockCursor.limit).toHaveBeenCalledWith(5);
     });
 
-    it('should apply only sort if skip and limit are missing', () => {
+    it("should apply only sort if skip and limit are missing", () => {
       const options = {
         sort: { name: 1 },
       };
 
       const result = applyQueryOptions(mockCursor, options);
-      
+
       expect(result).toBe(mockCursor);
       expect(mockCursor.sort).toHaveBeenCalledWith({ name: 1 });
       expect(mockCursor.skip).not.toHaveBeenCalled();

package/src/talkpilot/utils/query.utils.ts

@@ -1,4 +1,4 @@
-import { FindCursor } from 'mongodb';
+import { FindCursor } from "mongodb";
 
 export type QueryOptions = {
   sort?: any;
@@ -8,7 +8,7 @@ export type QueryOptions = {
 
 export const applyQueryOptions = <T>(
   cursor: FindCursor<T>,
-  options?: QueryOptions
+  options?: QueryOptions,
 ): FindCursor<T> => {
   if (!options) return cursor;