@talkpilot/core-db 1.1.8 → 1.1.9

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

@@ -1,4 +1,4 @@
-import type { Collection } from 'mongodb';
+import type { Collection } from "mongodb";
 import {
   Client,
   getClientsCollection,
@@ -7,32 +7,54 @@ import {
   ObjectId,
   findSubscriptions,
 } from '../index';
-import { PhoneNumber, PhoneNumberWithFlow } from './phone_numbers.types';
+import {
+  ClientPhoneNumberForFlow,
+  PhoneNumber,
+  PhoneNumberWithFlow,
+  PurchasedPhoneProviderPayload
+} from "./phone_numbers.types";
 
 export const getPhoneNumbersCollection = (): Collection<PhoneNumber> =>
-  getDb().collection<PhoneNumber>('phone_numbers');
+  getDb().collection<PhoneNumber>("phone_numbers");
 
 export const getPhoneDataByPhoneNumber = async (
-  phoneNumber: string
+  phoneNumber: string,
 ): Promise<PhoneNumberWithFlow | null> => {
-  const phoneCallData = await getPhoneNumbersCollection().findOne({ phone_number: phoneNumber });
+  const phoneCallData = await getPhoneNumbersCollection().findOne({
+    phone_number: phoneNumber,
+  });
   if (!phoneCallData) {
-    throw new Error('PhoneNumber not found');
+    throw new Error("PhoneNumber not found");
   }
-  const flow = await getFlowsCollection().findOne({ _id: new ObjectId(phoneCallData.flow_id) });
+  const flow = await getFlowsCollection().findOne({
+    _id: new ObjectId(phoneCallData.flow_id),
+  });
   if (!flow) {
-    throw new Error('Flow not found');
+    throw new Error("Flow not found");
   }
   const [subscription] =
-    (await findSubscriptions({ clientId: phoneCallData.client_id, isActive: true })) || [];
+    (await findSubscriptions({
+      clientId: phoneCallData.client_id,
+      isActive: true,
+    })) || [];
 
-  return { ...phoneCallData, flow, subscriptionId: subscription?._id?.toString() ?? undefined };
+  return {
+    ...phoneCallData,
+    flow,
+    subscriptionId: subscription?._id?.toString() ?? undefined,
+  };
 };
 
-export const getClientPrimaryPhoneNumber = async (clientId: string): Promise<string | null> => {
+export const getClientPrimaryPhoneNumber = async (
+  clientId: string,
+): Promise<string | null> => {
   return (
-    (await getPhoneNumbersCollection().findOne({ client_id: clientId, is_primary: true }))
-      ?.phone_number ?? null
+    (
+      await getPhoneNumbersCollection().findOne({
+        client_id: clientId,
+        is_primary: true,
+      })
+    )?.phone_number ?? null
   );
 };
 
@@ -40,17 +62,37 @@ export const getClientPhoneNumber = getClientPrimaryPhoneNumber;
 
 export const getClientPhoneData = async (
   clientId: string,
-  isPrimary?: boolean
+  isPrimary?: boolean,
 ): Promise<PhoneNumber | null> => {
   const filter = { client_id: clientId, is_primary: isPrimary !== false };
-  const options = isPrimary === false ? { sort: { createdAt: -1 } as const } : {};
+  const options =
+    isPrimary === false ? { sort: { createdAt: -1 } as const } : {};
   return getPhoneNumbersCollection().findOne(filter, options);
 };
 
+export const getPhoneNumbersForFlows = async (
+  clientId: string,
+): Promise<ClientPhoneNumberForFlow[]> => {
+  const docs = await getPhoneNumbersCollection()
+    .find({
+      client_id: clientId,
+      flow_id: { $exists: true, $type: "objectId" },
+    })
+    .project({ _id: 0, flow_id: 1, phone_number: 1, is_primary: 1 })
+    .sort({ createdAt: -1 })
+    .toArray();
+
+  return docs.map((doc) => ({
+    flowId: String(doc.flow_id),
+    phoneNumber: doc.phone_number,
+    isPrimary: doc.is_primary,
+  }));
+};
+
 export const createPhoneNumberEntity = async (
   phoneNumber: string,
   flowId: string,
-  clientId: string
+  clientId: string,
 ): Promise<PhoneNumber> => {
   const existing = await getClientPhoneData(clientId);
   const isPrimary = !existing;
@@ -64,15 +106,49 @@ export const createPhoneNumberEntity = async (
     updatedAt: new Date(),
   });
   const phoneNumberData = await getClientPhoneData(clientId, isPrimary);
-  if (!phoneNumberData) throw new Error('Failed to create phoneNumber');
+  if (!phoneNumberData) throw new Error("Failed to create phoneNumber");
   return phoneNumberData;
 };
 
+/** API-purchased number; `flowId` may be omitted until the number is bound to a flow. */
+export const createPurchasedPhoneNumber = async (
+  phoneNumber: string,
+  providerPayload: PurchasedPhoneProviderPayload,
+  clientId: string,
+  flowId?: string | null,
+): Promise<PhoneNumber> => {
+  const existingPhoneForClient = await getClientPhoneData(clientId);
+  const isPrimary = !existingPhoneForClient;
+
+  const now = new Date();
+  const trimmedFlowId = flowId?.trim();
+  const flowObjectId = trimmedFlowId ? new ObjectId(trimmedFlowId) : undefined;
+
+  const doc: PhoneNumber = {
+    phone_number: phoneNumber,
+    client_id: clientId,
+    is_primary: isPrimary,
+    ...providerPayload,
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  if (flowObjectId) {
+    doc.flow_id = flowObjectId;
+  }
+
+  await getPhoneNumbersCollection().insertOne(doc);
+
+  const created = await getClientPhoneData(clientId, isPrimary);
+  if (!created) throw new Error('Failed to create phoneNumber');
+  return created;
+};
+
 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');
+  if (!client) throw new Error("Failed to get client");
   return client;
 };

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

@@ -1,12 +1,15 @@
 export const phoneNumbersMongoSchema = {
   bsonType: 'object',
-  required: ['client_id', 'flow_id', 'phone_number'],
+  required: ['client_id', 'phone_number'],
   properties: {
     _id: { bsonType: 'objectId' },
     client_id: { bsonType: 'string' },
-    flow_id: { bsonType: 'string' },
+    flow_id: { bsonType: ['objectId', 'string'] },
     phone_number: { bsonType: 'string' },
     is_primary: { bsonType: 'bool' },
+    provider: { bsonType: 'string' },
+    provider_sid: { bsonType: 'string' },
+    friendly_name: { bsonType: 'string' },
     createdAt: { bsonType: 'date' },
     updatedAt: { bsonType: 'date' },
   },

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

@@ -1,15 +1,30 @@
-import { ObjectId, WithId } from "mongodb";
-import { Flow } from "../flows/flows.types";
+import { ObjectId, WithId } from 'mongodb';
+import { Flow } from '../flows/flows.types';
+
+export type PurchasedPhoneProviderPayload = {
+  provider: 'twilio' | 'telnyx';
+  provider_sid: string;
+  friendly_name?: string;
+};
 
 export type PhoneNumber = {
   _id?: ObjectId;
   client_id: string;
-  flow_id: ObjectId;
+  flow_id?: ObjectId;
   phone_number: string;
   subscriptionId?: string;
   is_primary: boolean;
+  provider?: 'twilio' | 'telnyx';
+  provider_sid?: string;
+  friendly_name?: string;
   createdAt: Date;
   updatedAt: Date;
 };
 
 export type PhoneNumberWithFlow = WithId<PhoneNumber> & { flow: Flow };
+
+export type ClientPhoneNumberForFlow = {
+  flowId: string;
+  phoneNumber: string;
+  isPrimary: boolean;
+};

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

@@ -5,61 +5,65 @@ import {
   countPlans,
   updatePlanDoc,
   getPlansCollection,
-} from '../plans.getters';
-import { ObjectId } from 'mongodb';
-import { Plan } from '../plans.types';
+} from "../plans.getters";
+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,9 +1,16 @@
-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");
 };
 
 /**
@@ -42,7 +49,7 @@ const buildSimpleQuery = (filter: SimplePlanFilter): Filter<Plan> => {
  */
 export const findPlans = async (
   filter?: PlanFilter,
-  options?: PlanQueryOptions
+  options?: PlanQueryOptions,
 ): Promise<PlanDoc[]> => {
   let query: Filter<Plan> = {};
 
@@ -81,7 +88,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();
@@ -92,7 +99,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({
@@ -102,24 +109,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,40 +1,44 @@
-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,2 +1,5 @@
-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,8 +1,9 @@
-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()}`;
@@ -10,17 +11,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;