@talkpilot/core-db 1.1.7 → 1.1.8

package/src/talkpilot/phone_numbers/phone_numbers.schema.ts

@@ -1,14 +1,14 @@
 export const phoneNumbersMongoSchema = {
-  bsonType: "object",
-  required: ["client_id", "flow_id", "phone_number"],
+  bsonType: 'object',
+  required: ['client_id', 'flow_id', 'phone_number'],
   properties: {
-    _id: { bsonType: "objectId" },
-    client_id: { bsonType: "string" },
-    flow_id: { bsonType: "string" },
-    phone_number: { bsonType: "string" },
-    is_primary: { bsonType: "bool" },
-    createdAt: { bsonType: "date" },
-    updatedAt: { bsonType: "date" },
+    _id: { bsonType: 'objectId' },
+    client_id: { bsonType: 'string' },
+    flow_id: { bsonType: 'string' },
+    phone_number: { bsonType: 'string' },
+    is_primary: { bsonType: 'bool' },
+    createdAt: { bsonType: 'date' },
+    updatedAt: { bsonType: 'date' },
   },
   additionalProperties: false,
 } as const;

package/src/talkpilot/phone_numbers/phone_numbers.types.ts

@@ -1,5 +1,5 @@
 import { ObjectId, WithId } from "mongodb";
-import { Flow } from "../flows";
+import { Flow } from "../flows/flows.types";
 
 export type PhoneNumber = {
   _id?: ObjectId;

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

@@ -5,65 +5,61 @@ import {
   countPlans,
   updatePlanDoc,
   getPlansCollection,
-} from "../plans.getters";
-import { Plan } from "../plans.types";
+} 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",
+describe('db.plans', () => {
+  const createTestPlan = (overrides?: Partial<Plan>): Omit<Plan, 'createdAt' | 'updatedAt'> => ({
+    productKey: 'basic-500',
+    name: 'Basic 500',
     monthlyCallQuota: 500,
-    currency: "ILS",
+    currency: 'ILS',
     priceMonthlyMinor: 10000,
     isActive: true,
     ...overrides,
   });
 
-  it("should create and find a plan", async () => {
-    const planData = createTestPlan({ name: "CreateTest" });
+  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");
+    expect(created.name).toBe('CreateTest');
 
     const found = await findPlans({ _id: created._id });
     expect(found.length).toBe(1);
-    expect(found[0].name).toBe("CreateTest");
+    expect(found[0].name).toBe('CreateTest');
   });
 
-  it("should find plans by query with limit", async () => {
+  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 }));
+    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 },
-    );
+    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 () => {
+  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" }));
+    await createPlanDoc(createTestPlan({ currency: 'USD' }));
+    await createPlanDoc(createTestPlan({ currency: 'USD' }));
+    await createPlanDoc(createTestPlan({ currency: 'ILS' }));
 
-    const count = await countPlans({ currency: "USD" });
+    const count = await countPlans({ currency: 'USD' });
     expect(count).toBe(2);
   });
 
-  it("should update a plan", async () => {
+  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/index.ts

@@ -1,2 +1,2 @@
-export * from "./plans.types";
-export * from "./plans.getters";
+export * from './plans.types';
+export * from './plans.getters';

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

@@ -1,16 +1,9 @@
-import {
-  getDb,
-  Plan,
-  PlanDoc,
-  PlanFilter,
-  PlanQueryOptions,
-  SimplePlanFilter,
-} from "../index";
-import { Filter, ObjectId } from "mongodb";
-import { applyQueryOptions } from "../utils/query.utils";
+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");
+  return getDb().collection<Plan>('plans');
 };
 
 /**
@@ -49,7 +42,7 @@ const buildSimpleQuery = (filter: SimplePlanFilter): Filter<Plan> => {
  */
 export const findPlans = async (
   filter?: PlanFilter,
-  options?: PlanQueryOptions,
+  options?: PlanQueryOptions
 ): Promise<PlanDoc[]> => {
   let query: Filter<Plan> = {};
 
@@ -88,7 +81,7 @@ export const findPlans = async (
 
 export const findPlansByQuery = async (
   query: Filter<Plan>,
-  options?: PlanQueryOptions,
+  options?: PlanQueryOptions
 ): Promise<PlanDoc[]> => {
   const cursor = getPlansCollection().find(query);
   return await applyQueryOptions(cursor, options).toArray();
@@ -99,7 +92,7 @@ export const countPlans = async (query: Filter<Plan>): Promise<number> => {
 };
 
 export const createPlanDoc = async (
-  planData: Omit<Plan, "createdAt" | "updatedAt">,
+  planData: Omit<Plan, 'createdAt' | 'updatedAt'>
 ): Promise<PlanDoc> => {
   const now = new Date();
   const result = await getPlansCollection().insertOne({
@@ -109,24 +102,24 @@ export const createPlanDoc = async (
   });
 
   const plans = await findPlans({ _id: result.insertedId });
-  if (!plans[0]) throw new Error("Failed to retrieve created plan");
+  if (!plans[0]) throw new Error('Failed to retrieve created plan');
   return plans[0];
 };
 
 export const updatePlanDoc = async (
   planId: ObjectId,
-  updates: Partial<Omit<Plan, "createdAt" | "updatedAt">>,
+  updates: Partial<Omit<Plan, 'createdAt' | 'updatedAt'>>
 ): Promise<PlanDoc | null> => {
   return await getPlansCollection().findOneAndUpdate(
-    { _id: planId },
-    {
-      $set: {
-        ...updates,
-        updatedAt: new Date(),
+      {_id: planId},
+      {
+        $set: {
+          ...updates,
+          updatedAt: new Date(),
+        },
       },
-    },
-    {
-      returnDocument: "after",
-    },
+      {
+        returnDocument: 'after',
+      }
   );
 };

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

@@ -1,44 +1,40 @@
-import { Sort, ObjectId, WithId } from "mongodb";
+import { Sort, ObjectId, WithId } from 'mongodb';
 
-export const CURRENCY_CODES = ["ILS", "USD", "EUR"] as const;
+export const CURRENCY_CODES = ['ILS', 'USD', 'EUR'] as const;
 export type CurrencyCode = (typeof CURRENCY_CODES)[number];
 
 /** Required fields for creating a new plan */
 export const PLAN_REQUIRED_FIELDS = [
-  "productKey",
-  "name",
-  "monthlyCallQuota",
-  "currency",
-  "priceMonthlyMinor",
-  "isActive",
+  'productKey',
+  'name',
+  'monthlyCallQuota',
+  'currency',
+  'priceMonthlyMinor',
+  'isActive',
 ];
 
 /** All allowed fields that can be set/updated on a plan (excluding system fields) */
 export const PLAN_ALLOWED_FIELDS = [
-  "productKey",
-  "name",
-  "monthlyCallQuota",
-  "currency",
-  "priceMonthlyMinor",
-  "region",
-  "countryCode",
-  "isActive",
-  "originalPlanId",
-  "tax",
-  "metadata",
-  "updatedAt",
+  'productKey',
+  'name',
+  'monthlyCallQuota',
+  'currency',
+  'priceMonthlyMinor',
+  'region',
+  'countryCode',
+  'isActive',
+  'originalPlanId',
+  'tax',
+  'metadata',
+  'updatedAt',
 ];
 
 /** Logical product family, like "basic-500". Multiple regional variants can share it. */
-export type ProductKey =
-  | "basic-500"
-  | "pro-1100"
-  | "scale-6000"
-  | (string & {});
+export type ProductKey = 'basic-500' | 'pro-1100' | 'scale-6000' | (string & {});
 
 /** Optional targeting to keep variants explicit */
-export type RegionCode = "IL" | "EU" | "US" | (string & {});
-export type CountryCode = "IL" | "DE" | "FR" | "ES" | "GB" | (string & {});
+export type RegionCode = 'IL' | 'EU' | 'US' | (string & {});
+export type CountryCode = 'IL' | 'DE' | 'FR' | 'ES' | 'GB' | (string & {});
 
 export type Tax = {
   vatIncluded: boolean;

package/src/talkpilot/results/index.ts

@@ -1,5 +1,2 @@
-export {
-  getResultsCollection,
-  initializeResultDocument,
-} from "./results.getter";
-export type * from "./results.types";
+export { getResultsCollection, initializeResultDocument } from './results.getter';
+export type * from './results.types';

package/src/talkpilot/results/results.getter.ts

@@ -1,9 +1,8 @@
-import type { Collection } from "mongodb";
-import { getDb, ObjectId, Session } from "../index";
-import type { Result } from "./results.types";
+import type { Collection } from 'mongodb';
+import { getDb, ObjectId, Session } from '../index';
+import type { Result } from './results.types';
 
-export const getResultsCollection = (): Collection<Result> =>
-  getDb().collection<Result>("results");
+export const getResultsCollection = (): Collection<Result> => getDb().collection<Result>('results');
 
 export const createRunId = (): string => {
   return `run_${new ObjectId().toString()}`;
@@ -11,17 +10,17 @@ export const createRunId = (): string => {
 
 export const initializeResultDocument = async (
   clientId: string,
-  session?: Session,
+  session?: Session
 ): Promise<Result> => {
   const { insertedId } = await getResultsCollection().insertOne({
     runId: createRunId(),
     date: new Date(),
     calls: [],
-    sessionId: session ? session._id!.toString() : "incomingCall",
-    sessionName: session ? session.session_name : "incomingCall",
+    sessionId: session ? session._id!.toString() : 'incomingCall',
+    sessionName: session ? session.session_name : 'incomingCall',
     clientId,
   });
   const result = await getResultsCollection().findOne({ _id: insertedId });
-  if (!result) throw new Error("Failed to initialized result");
+  if (!result) throw new Error('Failed to initialized result');
   return result;
 };

package/src/talkpilot/results/results.schema.ts

@@ -1,25 +1,25 @@
 export const resultMongoSchema = {
-  bsonType: "object",
+  bsonType: 'object',
   required: [
-    "_id",
-    "sessionId",
-    "status",
-    "callLength",
-    "date",
-    "userAnswer",
-    "systemSessionId",
-    "clientId",
+    '_id',
+    'sessionId',
+    'status',
+    'callLength',
+    'date',
+    'userAnswer',
+    'systemSessionId',
+    'clientId',
   ],
   properties: {
-    _id: { bsonType: "objectId" },
-    sessionId: { bsonType: "string" },
-    status: { bsonType: "string" },
-    callLength: { bsonType: "string" },
-    date: { bsonType: "date" },
-    userAnswer: { bsonType: "string" },
-    recordingUrl: { bsonType: ["string", "null"] },
-    systemSessionId: { bsonType: "string" },
-    clientId: { bsonType: "string" },
+    _id: { bsonType: 'objectId' },
+    sessionId: { bsonType: 'string' },
+    status: { bsonType: 'string' },
+    callLength: { bsonType: 'string' },
+    date: { bsonType: 'date' },
+    userAnswer: { bsonType: 'string' },
+    recordingUrl: { bsonType: ['string', 'null'] },
+    systemSessionId: { bsonType: 'string' },
+    clientId: { bsonType: 'string' },
   },
   additionalProperties: false,
 } as const;

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

@@ -1,4 +1,4 @@
-import { ObjectId } from "mongodb";
+import { ObjectId } from 'mongodb';
 
 export interface Result {
   _id?: ObjectId;

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

@@ -1,52 +1,39 @@
-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";
+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';
       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,
       });
 
@@ -60,20 +47,15 @@ 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);
@@ -81,28 +63,25 @@ 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);
@@ -113,19 +92,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);
@@ -136,11 +115,8 @@ 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,22 +1,20 @@
-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> => {
@@ -38,12 +36,9 @@ 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) => {
@@ -73,9 +68,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] },
             },
           },
         },
@@ -85,7 +80,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;