@talkpilot/core-db 1.3.57 → 1.3.58

package/src/talkpilot/phone_numbers/index.ts

@@ -1,2 +1,2 @@
-export * from "./phone_numbers.getter";
-export type * from "./phone_numbers.types";
+export * from "./phone_numbers.getter";
+export type * from "./phone_numbers.types";

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

@@ -1,240 +1,176 @@
-import type { Collection } from "mongodb";
-import {
-  Client,
-  getClientsCollection,
-  getDb,
-  getFlowsCollection,
-  ObjectId,
-  findSubscriptions,
-} from "../index";
-import {
-  ClientPhoneNumberForFlow,
-  PhoneNumber,
-  PhoneNumberWithFlow,
-  PurchasedPhoneProviderPayload,
-} from "./phone_numbers.types";
-import { flowIdAsObjectIdOrString } from "./phone_numbers.utils";
-
-export const getPhoneNumbersCollection = (): Collection<PhoneNumber> =>
-  getDb().collection<PhoneNumber>("phone_numbers");
-
-export const getPhoneDataByPhoneNumber = async (
-  phoneNumber: string,
-): Promise<PhoneNumberWithFlow | null> => {
-  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 getClientPrimaryPhoneNumber = async (
-  clientId: string,
-): Promise<string | null> => {
-  return (
-    (
-      await getPhoneNumbersCollection().findOne({
-        client_id: clientId,
-        is_primary: true,
-      })
-    )?.phone_number ?? null
-  );
-};
-
-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 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,
-): Promise<PhoneNumber> => {
-  const existing = await getClientPhoneData(clientId);
-  const isPrimary = !existing;
-
-  await getPhoneNumbersCollection().insertOne({
-    phone_number: phoneNumber,
-    flow_id: new ObjectId(flowId),
-    client_id: clientId,
-    is_primary: isPrimary,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  });
-  const phoneNumberData = await getClientPhoneData(clientId, isPrimary);
-  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");
-  return client;
-};
-
-export const getPrimaryPhoneFlowId = async (clientId: string): Promise<string | null> => {
-  const phone = await getClientPhoneData(clientId);
-  return phone?.flow_id ? String(phone.flow_id) : null;
-};
-
-export const bindClientPhoneToFlow = async (
-  clientId: string,
-  flowId: string,
-): Promise<void> => {
-  const result = await getPhoneNumbersCollection().updateOne(
-    { client_id: clientId, is_primary: true },
-    { $set: { flow_id: new ObjectId(flowId), updatedAt: new Date() } },
-  );
-  if (result.matchedCount === 0) {
-    throw new Error(`No primary phone number found for client: ${clientId}`);
-  }
-};
-
-export const findPhoneNumbersByClientId = (
-  clientId: string,
-): Promise<PhoneNumber[]> =>
-  getPhoneNumbersCollection().find({ client_id: clientId }).toArray();
-
-export const getOwnedPhoneNumber = (
-  clientId: string,
-  phoneNumber: string,
-): Promise<PhoneNumber | null> =>
-  getPhoneNumbersCollection().findOne({
-    client_id: clientId,
-    phone_number: phoneNumber,
-  });
-
-export const getPhoneNumberByClientAndFlow = (
-  clientId: string,
-  flowId: string,
-): Promise<PhoneNumber | null> =>
-  getPhoneNumbersCollection().findOne({
-    client_id: clientId,
-    $or: flowIdAsObjectIdOrString(flowId),
-  });
-
-export const clearPhoneNumberFlow = async (
-  clientId: string,
-  phoneNumber: string,
-): Promise<void> => {
-  await getPhoneNumbersCollection().updateOne(
-    { client_id: clientId, phone_number: phoneNumber },
-    { $unset: { flow_id: "" }, $set: { updatedAt: new Date() } },
-  );
-};
-
-export const assignExclusiveFlow = async (
-  clientId: string,
-  phoneNumber: string,
-  flowId: string,
-): Promise<void> => {
-  const collection = getPhoneNumbersCollection();
-  await collection.updateMany(
-    {
-      client_id: clientId,
-      phone_number: { $ne: phoneNumber },
-      $or: flowIdAsObjectIdOrString(flowId),
-    },
-    { $unset: { flow_id: "" }, $set: { updatedAt: new Date() } },
-  );
-  await collection.updateOne(
-    { client_id: clientId, phone_number: phoneNumber },
-    { $set: { flow_id: new ObjectId(flowId), updatedAt: new Date() } },
-  );
-};
-
-export const unbindFlowFromClientNumbers = async (
-  clientId: string,
-  flowId: string,
-): Promise<void> => {
-  await getPhoneNumbersCollection().updateMany(
-    { client_id: clientId, $or: flowIdAsObjectIdOrString(flowId) },
-    { $unset: { flow_id: "" }, $set: { updatedAt: new Date() } },
-  );
-};
+import type { Collection } from "mongodb";
+import {
+  Client,
+  getClientsCollection,
+  getDb,
+  getFlowsCollection,
+  ObjectId,
+  findSubscriptions,
+} from "../index";
+import {
+  ClientPhoneNumberForFlow,
+  PhoneNumber,
+  PhoneNumberWithFlow,
+  PurchasedPhoneProviderPayload,
+} from "./phone_numbers.types";
+
+export const getPhoneNumbersCollection = (): Collection<PhoneNumber> =>
+  getDb().collection<PhoneNumber>("phone_numbers");
+
+export const getPhoneDataByPhoneNumber = async (
+  phoneNumber: string,
+): Promise<PhoneNumberWithFlow | null> => {
+  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 getClientPrimaryPhoneNumber = async (
+  clientId: string,
+): Promise<string | null> => {
+  return (
+    (
+      await getPhoneNumbersCollection().findOne({
+        client_id: clientId,
+        is_primary: true,
+      })
+    )?.phone_number ?? null
+  );
+};
+
+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 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,
+): Promise<PhoneNumber> => {
+  const existing = await getClientPhoneData(clientId);
+  const isPrimary = !existing;
+
+  await getPhoneNumbersCollection().insertOne({
+    phone_number: phoneNumber,
+    flow_id: new ObjectId(flowId),
+    client_id: clientId,
+    is_primary: isPrimary,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  });
+  const phoneNumberData = await getClientPhoneData(clientId, isPrimary);
+  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");
+  return client;
+};
+
+export const getPrimaryPhoneFlowId = async (clientId: string): Promise<string | null> => {
+  const phone = await getClientPhoneData(clientId);
+  return phone?.flow_id ? String(phone.flow_id) : null;
+};
+
+export const bindClientPhoneToFlow = async (
+  clientId: string,
+  flowId: string,
+): Promise<void> => {
+  const result = await getPhoneNumbersCollection().updateOne(
+    { client_id: clientId, is_primary: true },
+    { $set: { flow_id: new ObjectId(flowId), updatedAt: new Date() } },
+  );
+  if (result.matchedCount === 0) {
+    throw new Error(`No primary phone number found for client: ${clientId}`);
+  }
+};

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

@@ -1,17 +1,17 @@
-export const phoneNumbersMongoSchema = {
-  bsonType: "object",
-  required: ["client_id", "phone_number"],
-  properties: {
-    _id: { bsonType: "objectId" },
-    client_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" },
-  },
-  additionalProperties: false,
-} as const;
+export const phoneNumbersMongoSchema = {
+  bsonType: "object",
+  required: ["client_id", "phone_number"],
+  properties: {
+    _id: { bsonType: "objectId" },
+    client_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" },
+  },
+  additionalProperties: false,
+} as const;

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

@@ -1,30 +1,30 @@
-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;
-  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;
-};
+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;
+  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

@@ -1,70 +1,70 @@
-import {
-  createPlanDoc,
-  findPlans,
-  findPlansByQuery,
-  countPlans,
-  updatePlanDoc,
-  getPlansCollection,
-} 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",
-    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);
-  });
-});
+import {
+  createPlanDoc,
+  findPlans,
+  findPlansByQuery,
+  countPlans,
+  updatePlanDoc,
+  getPlansCollection,
+} 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",
+    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);
+  });
+});