@talkpilot/core-db 1.0.4 → 1.0.11

package/src/talkpilot/phone_numbers/phone_numbers.getter.ts

@@ -1,7 +1,13 @@
 import type { Collection } from 'mongodb';
-import { getDb, ObjectId } from '../index';
-import { findFlowById } from '../flows/flows.getter';
-import type { PhoneNumber, PhoneNumberWithFlow } from './phone_numbers.types';
+import {
+  Client,
+  getClientsCollection,
+  getDb,
+  getFlowsCollection,
+  ObjectId,
+  findSubscriptions,
+} from '../index';
+import { PhoneNumber, PhoneNumberWithFlow } from './phone_numbers.types';
 
 export const getPhoneNumbersCollection = (): Collection<PhoneNumber> =>
   getDb().collection<PhoneNumber>('phone_numbers');
@@ -9,30 +15,46 @@ export const getPhoneNumbersCollection = (): Collection<PhoneNumber> =>
 export const getPhoneDataByPhoneNumber = async (
   phoneNumber: string
 ): Promise<PhoneNumberWithFlow | null> => {
-  const phoneData = await getPhoneNumbersCollection().findOne({ phone_number: phoneNumber });
-  if (!phoneData) return null;
-  const flow = await findFlowById(phoneData.flow_id, phoneData.client_id);
-  if (!flow) return null;
-  return { ...phoneData, flow };
+  const phoneCallData = await getPhoneNumbersCollection().findOne({ phone_number: phoneNumber });
+  if (!phoneCallData) {
+    throw new Error('PhoneNumber not found');
+  }
+  const flow = await getFlowsCollection().findOne({ _id: new ObjectId(phoneCallData.flow_id) });
+  if (!flow) {
+    throw new Error('Flow not found');
+  }
+  const [subscription] =
+    (await findSubscriptions({ clientId: phoneCallData.client_id, isActive: true })) || [];
+
+  return { ...phoneCallData, flow, subscriptionId: subscription?._id?.toString() ?? undefined };
 };
 
-export const getClientPhoneNumber = async (clientId: string): Promise<string | null> => {
-  return (await getPhoneNumbersCollection().findOne({ client_id: clientId }))?.phone_number ?? null;
+export const getClientPrimaryPhoneNumber = async (clientId: string): Promise<string | null> => {
+  return (
+    (await getPhoneNumbersCollection().findOne({ client_id: clientId, is_primary: true }))
+      ?.phone_number ?? null
+  );
 };
 
-export const getClientPhoneData = async (clientId: string): Promise<PhoneNumber | null> => {
-  const phoneNumberData = await getPhoneNumbersCollection().findOne({
-    client_id: clientId,
-  });
-  return phoneNumberData;
+export const getClientPhoneNumber = getClientPrimaryPhoneNumber;
+
+export const getClientPhoneData = async (
+  clientId: string,
+  isPrimary?: boolean
+): Promise<PhoneNumber | null> => {
+  const filter = { client_id: clientId, is_primary: isPrimary !== false };
+  const options = isPrimary === false ? { sort: { createdAt: -1 } as const } : {};
+  return getPhoneNumbersCollection().findOne(filter, options);
 };
 
 export const createPhoneNumberEntity = async (
   phoneNumber: string,
   flowId: string,
-  clientId: string,
-  isPrimary = true,
+  clientId: string
 ): Promise<PhoneNumber> => {
+  const existing = await getClientPhoneData(clientId);
+  const isPrimary = !existing;
+
   await getPhoneNumbersCollection().insertOne({
     phone_number: phoneNumber,
     flow_id: new ObjectId(flowId),
@@ -41,7 +63,16 @@ export const createPhoneNumberEntity = async (
     createdAt: new Date(),
     updatedAt: new Date(),
   });
-  const phoneNumberData = await getClientPhoneData(clientId);
+  const phoneNumberData = await getClientPhoneData(clientId, isPrimary);
   if (!phoneNumberData) throw new Error('Failed to create phoneNumber');
   return phoneNumberData;
 };
+
+export const findClientByPhoneNumber = async (phoneNumber: string): Promise<Client> => {
+  const phoneData = await getPhoneNumbersCollection().findOne({ phone_number: phoneNumber });
+  if (!phoneData) throw new Error('Failed to get phone data');
+  const clientId = phoneData.client_id;
+  const client = await getClientsCollection().findOne({ clientId });
+  if (!client) throw new Error('Failed to get client');
+  return client;
+};

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

@@ -0,0 +1,66 @@
+import {
+  createPlanDoc,
+  findPlans,
+  findPlansByQuery,
+  countPlans,
+  updatePlanDoc,
+  getPlansCollection,
+} from '../plans.getters';
+import { ObjectId } from 'mongodb';
+import { Plan } from '../plans.types';
+
+describe('db.plans', () => {
+  const createTestPlan = (overrides?: Partial<Plan>): Omit<Plan, 'createdAt' | 'updatedAt'> => ({
+    productKey: 'basic-500',
+    name: 'Basic 500',
+    monthlyCallQuota: 500,
+    currency: 'ILS',
+    priceMonthlyMinor: 10000,
+    isActive: true,
+    ...overrides,
+  });
+
+  it('should create and find a plan', async () => {
+    const planData = createTestPlan({ name: 'CreateTest' });
+    const created = await createPlanDoc(planData);
+    
+    expect(created._id).toBeDefined();
+    expect(created.name).toBe('CreateTest');
+
+    const found = await findPlans({ _id: created._id });
+    expect(found.length).toBe(1);
+    expect(found[0].name).toBe('CreateTest');
+  });
+
+  it('should find plans by query with limit', async () => {
+    await getPlansCollection().deleteMany({});
+    await createPlanDoc(createTestPlan({ productKey: 'p1', isActive: true }));
+    await createPlanDoc(createTestPlan({ productKey: 'p2', isActive: true }));
+    await createPlanDoc(createTestPlan({ productKey: 'p3', isActive: false }));
+
+    const activePlans = await findPlansByQuery({ isActive: true }, { limit: 1 });
+    expect(activePlans.length).toBe(1);
+    expect(activePlans[0].isActive).toBe(true);
+  });
+
+  it('should count plans matching query', async () => {
+    await getPlansCollection().deleteMany({});
+    await createPlanDoc(createTestPlan({ currency: 'USD' }));
+    await createPlanDoc(createTestPlan({ currency: 'USD' }));
+    await createPlanDoc(createTestPlan({ currency: 'ILS' }));
+
+    const count = await countPlans({ currency: 'USD' });
+    expect(count).toBe(2);
+  });
+
+  it('should update a plan', async () => {
+    const plan = await createPlanDoc(createTestPlan({ isActive: true }));
+    const updated = await updatePlanDoc(plan._id, { isActive: false });
+    
+    expect(updated).not.toBeNull();
+    expect(updated?.isActive).toBe(false);
+    
+    const found = await findPlans({ _id: plan._id });
+    expect(found[0].isActive).toBe(false);
+  });
+});

package/src/talkpilot/plans/plans.getters.ts

@@ -1,5 +1,6 @@
-import { Plan, getDb, PlanDoc, PlanFilter, SimplePlanFilter, PlanQueryOptions } from '../index';
-import { ObjectId, Filter } from 'mongodb';
+import {getDb, Plan, PlanDoc, PlanFilter, PlanQueryOptions, SimplePlanFilter} from '../index';
+import {Filter, ObjectId} from 'mongodb';
+import {applyQueryOptions} from '../utils/query.utils';
 
 export const getPlansCollection = () => {
   return getDb().collection<Plan>('plans');
@@ -74,16 +75,20 @@ export const findPlans = async (
     }
   }
 
-  let queryBuilder = getPlansCollection().find(query);
+  const cursor = getPlansCollection().find(query);
+  return await applyQueryOptions(cursor, options).toArray();
+};
 
-  if (options?.sort) {
-    queryBuilder = queryBuilder.sort(options.sort);
-  }
-  if (options?.limit) {
-    queryBuilder = queryBuilder.limit(options.limit);
-  }
+export const findPlansByQuery = async (
+  query: Filter<Plan>,
+  options?: PlanQueryOptions
+): Promise<PlanDoc[]> => {
+  const cursor = getPlansCollection().find(query);
+  return await applyQueryOptions(cursor, options).toArray();
+};
 
-  return await queryBuilder.toArray();
+export const countPlans = async (query: Filter<Plan>): Promise<number> => {
+  return getPlansCollection().countDocuments(query);
 };
 
 export const createPlanDoc = async (
@@ -103,19 +108,18 @@ export const createPlanDoc = async (
 
 export const updatePlanDoc = async (
   planId: ObjectId,
-  updates: Partial<Pick<Plan, 'isActive'>>
+  updates: Partial<Omit<Plan, 'createdAt' | 'updatedAt'>>
 ): Promise<PlanDoc | null> => {
-  const result = await getPlansCollection().findOneAndUpdate(
-    { _id: planId },
-    {
-      $set: {
-        ...updates,
-        updatedAt: new Date(),
+  return await getPlansCollection().findOneAndUpdate(
+      {_id: planId},
+      {
+        $set: {
+          ...updates,
+          updatedAt: new Date(),
+        },
       },
-    },
-    {
-      returnDocument: 'after',
-    }
+      {
+        returnDocument: 'after',
+      }
   );
-  return result;
 };

package/src/talkpilot/plans/plans.types.ts

@@ -76,6 +76,7 @@ export type PlanFilter = SimplePlanFilter & {
 
 export type PlanQueryOptions = {
   sort?: Sort;
+  skip?: number;
   limit?: number;
 };
 

package/src/talkpilot/results/results.types.ts

@@ -25,6 +25,8 @@ export interface CallResult {
   transcription: TranscriptionSegment[];
   flowId: ObjectId | string;
   recordingUrl: string | null;
+  agentHungUp?: boolean;
+  endReason?: string;
 }
 
 export type TranscriptionSegment =

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/index.ts

@@ -1,2 +1,2 @@
-export { getSessionsCollection } from './sessions.getter';
-export type { Session } from './sessions.types';
+export * from './sessions.getter';
+export * from './sessions.types';

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/subscriptions/subscriptions.types.ts

@@ -61,5 +61,6 @@ export type SubscriptionFilter = SimpleSubscriptionFilter & {
  */
 export type SubscriptionQueryOptions = {
   sort?: Sort;
+  skip?: number;
   limit?: number;
 };

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