@talkpilot/core-db 1.0.4 → 1.0.7

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

@@ -3,20 +3,16 @@ 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 = faker.phone.number();
-      const from = faker.phone.number();
+      const to = '+972500000000';
+      const from = '+972540000000';
       const flow = createFlow();
       const phoneNumberData = createPhoneNumber({ phone_number: to, flow_id: flow._id });
-      const json = {
-        [faker.lorem.word()]: faker.lorem.sentence(),
-        [faker.lorem.word()]: faker.number.int(),
-        [faker.lorem.word()]: faker.datatype.boolean(),
-        [faker.lorem.word()]: faker.internet.email(),
-      };
+      const json = { [faker.lorem.word()]: faker.lorem.sentence() };
 
       const session = createSession({
         flow_id: flow._id,
@@ -29,10 +25,77 @@ describe('sessions', () => {
       await getSessionsCollection().insertOne(session);
 
       const result = await findSessionOfIncomingCall(from, to);
-      expect(result).toBeDefined();
+      expect(result).not.toBeNull();
       expect(result?.phone_numbers[0].phoneNumber).toEqual(from);
       expect(result?.flow_id).toEqual(flow._id);
-      expect(result?.json).toEqual(json);
+    });
+
+    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 session = createSession({
+        flow_id: flow._id,
+        phone_numbers: [{ phoneNumber: fromInDB, gender: 'female', name: 'sara' }],
+      });
+
+      await getFlowsCollection().insertOne(flow);
+      await getPhoneNumbersCollection().insertOne(phoneNumberData);
+      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');
+      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';
+      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 session = createSession({
+        flow_id: flowId, // stored as ObjectId
+        phone_numbers: [{ phoneNumber: from, gender: 'male', name: 'isaac' }],
+      });
+
+      await getPhoneNumbersCollection().insertOne(phoneNumberData);
+      await getSessionsCollection().insertOne(session);
+
+      const result = await findSessionOfIncomingCall(from, to);
+      expect(result).not.toBeNull();
+      expect(result?.flow_id?.toString()).toEqual(flowId.toHexString());
+    });
+
+    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 session = createSession({
+        flow_id: flowId.toHexString(), // stored as string
+        phone_numbers: [{ phoneNumber: from, gender: 'female', name: 'rivka' }],
+      });
+
+      await getPhoneNumbersCollection().insertOne(phoneNumberData);
+      await getSessionsCollection().insertOne(session);
+
+      const result = await findSessionOfIncomingCall(from, to);
+      expect(result).not.toBeNull();
+      expect(result?.flow_id).toEqual(flowId.toHexString());
     });
 
     it('returns null if receiver phone number is not found', async () => {

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

@@ -6,6 +6,34 @@ import type { Session } from './sessions.types';
 export const getSessionsCollection = (): Collection<Session> =>
   getDb().collection<Session>('sessions');
 
+const buildPhoneCandidates = (phone: string): string[] => {
+  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, '');
+
+  return Array.from(new Set([raw, noPlus, digitsOnly, digitsOnlyNoPlus].filter(Boolean)));
+};
+
+const buildFlowIdCandidates = (flowId: unknown): Array<string | ObjectId> => {
+  if (!flowId) return [];
+
+  // Some sessions store flow_id as string, others as ObjectId.
+  if (flowId instanceof ObjectId) {
+    return [flowId, flowId.toString()];
+  }
+
+  const asString = String(flowId);
+  if (!asString) return [];
+
+  if (ObjectId.isValid(asString)) {
+    return [new ObjectId(asString), asString];
+  }
+  return [asString];
+};
+
 export const findSessionById = (
   sessionId: ObjectId,
   clientId: string
@@ -14,15 +42,46 @@ export const findSessionById = (
 };
 
 export const findSessionOfIncomingCall = async (from: string, to: string) => {
-  const receiverPhoneData = await getPhoneNumbersCollection().findOne({ phone_number: to });
+  const toCandidates = buildPhoneCandidates(to);
+  const fromCandidates = buildPhoneCandidates(from);
+
+  const receiverPhoneData = await getPhoneNumbersCollection().findOne({
+    phone_number: { $in: toCandidates },
+  });
   if (!receiverPhoneData) {
     return null;
   }
-  const session = await getSessionsCollection().findOne({
-    flow_id: new ObjectId(receiverPhoneData.flow_id),
-    phone_numbers: {
-      $elemMatch: { phoneNumber: from },
-    },
-  });
+
+  const flowIdCandidates = buildFlowIdCandidates(receiverPhoneData.flow_id);
+
+  const [session] = await getSessionsCollection()
+    .aggregate<WithId<Session>>([
+      {
+        $match: {
+          flow_id: { $in: flowIdCandidates },
+          phone_numbers: {
+            $elemMatch: { phoneNumber: { $in: fromCandidates } },
+          },
+        },
+      },
+      {
+        $addFields: {
+          phone_numbers: {
+            $filter: {
+              input: '$phone_numbers',
+              as: 'pn',
+              cond: { $in: ['$$pn.phoneNumber', fromCandidates] },
+            },
+          },
+        },
+      },
+      { $limit: 1 },
+    ])
+    .toArray();
+
+  if (!session) {
+    console.info('No session found for incoming call');
+    return null;
+  }
   return session;
 };

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

@@ -1,13 +1,14 @@
-import { getDb } from '../index';
+import {getDb} from '../index';
 import {
+  SimpleSubscriptionFilter,
   Subscription,
   SubscriptionDoc,
-  SimpleSubscriptionFilter,
   SubscriptionFilter,
   SubscriptionQueryOptions,
 } from './subscriptions.types';
-import { ObjectId, Filter } from 'mongodb';
-import { buildSimpleQuery } from './subscriptions.getters.utils';
+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');
@@ -46,15 +47,12 @@ export const findSubscriptions = async (
     }
   }
 
-  let queryBuilder = getSubscriptionsCollection().find(query);
-  if (options?.sort) {
-    queryBuilder = queryBuilder.sort(options.sort);
-  }
-  if (options?.limit) {
-    queryBuilder = queryBuilder.limit(options.limit);
-  }
+  const cursor = getSubscriptionsCollection().find(query);
+  return await applyQueryOptions(cursor, options).toArray();
+};
 
-  return await queryBuilder.toArray();
+export const countSubscriptions = async (query: Filter<Subscription>): Promise<number> => {
+  return getSubscriptionsCollection().countDocuments(query);
 };
 
 export const createSubscriptionDoc = async (
@@ -131,17 +129,15 @@ export const pushNewSubscriptionCycle = async (
   subscriptionId: ObjectId,
   newCycle: Subscription['cycles'][number]
 ): Promise<SubscriptionDoc | null> => {
-  const result = await getSubscriptionsCollection().findOneAndUpdate(
-    { _id: subscriptionId },
-    {
-      $push: {
-        cycles: newCycle,
+  return await getSubscriptionsCollection().findOneAndUpdate(
+      {_id: subscriptionId},
+      {
+        $push: {
+          cycles: newCycle,
+        },
       },
-    },
-    {
-      returnDocument: 'after',
-    }
+      {
+        returnDocument: 'after',
+      }
   );
-
-  return result;
 };

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

@@ -0,0 +1,49 @@
+import { applyQueryOptions } from '../query.utils';
+
+describe('query.utils', () => {
+  describe('applyQueryOptions()', () => {
+    let mockCursor: any;
+
+    beforeEach(() => {
+      mockCursor = {
+        sort: jest.fn().mockReturnThis(),
+        skip: jest.fn().mockReturnThis(),
+        limit: jest.fn().mockReturnThis(),
+      };
+    });
+
+    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', () => {
+      const options = {
+        sort: { name: 1 },
+        skip: 10,
+        limit: 5,
+      };
+
+      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', () => {
+      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();
+      expect(mockCursor.limit).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -0,0 +1,21 @@
+import { FindCursor } from 'mongodb';
+
+export type QueryOptions = {
+  sort?: any;
+  skip?: number;
+  limit?: number;
+};
+
+export const applyQueryOptions = <T>(
+  cursor: FindCursor<T>,
+  options?: QueryOptions
+): FindCursor<T> => {
+  if (!options) return cursor;
+
+  let result = cursor;
+  if (options.sort) result = result.sort(options.sort);
+  if (options.skip) result = result.skip(options.skip);
+  if (options.limit) result = result.limit(options.limit);
+
+  return result;
+};