@talkpilot/core-db 1.3.83 → 1.3.85

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

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,132 +1,132 @@
-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");
-};
-
-/**
- * Converts a simple filter to MongoDB query format
- */
-const buildSimpleQuery = (filter: SimplePlanFilter): Filter<Plan> => {
-  const query: Filter<Plan> = {};
-
-  if (filter._id) {
-    query._id = new ObjectId(filter._id);
-  }
-  if (filter.productKey !== undefined) {
-    query.productKey = filter.productKey;
-  }
-  if (filter.isActive !== undefined) {
-    query.isActive = filter.isActive;
-  }
-  if (filter.currency !== undefined) {
-    query.currency = filter.currency;
-  }
-  if (filter.region !== undefined) {
-    query.region = filter.region;
-  }
-  if (filter.countryCode !== undefined) {
-    query.countryCode = filter.countryCode;
-  }
-  if (filter.originalPlanId !== undefined) {
-    query.originalPlanId = filter.originalPlanId;
-  }
-
-  return query;
-};
-
-/**
- * Generic function to find plans with flexible filtering
- */
-export const findPlans = async (
-  filter?: PlanFilter,
-  options?: PlanQueryOptions,
-): Promise<PlanDoc[]> => {
-  let query: Filter<Plan> = {};
-
-  if (filter) {
-    // Build the base query from simple filter properties
-    const simpleFilter: SimplePlanFilter = {
-      _id: filter._id,
-      productKey: filter.productKey,
-      isActive: filter.isActive,
-      currency: filter.currency,
-      region: filter.region,
-      countryCode: filter.countryCode,
-      originalPlanId: filter.originalPlanId,
-    };
-
-    // Apply simple filters if any are present
-    const baseQuery = buildSimpleQuery(simpleFilter);
-    if (Object.keys(baseQuery).length > 0) {
-      query = baseQuery;
-    }
-
-    // Add OR conditions if present
-    if (filter.or && filter.or.length > 0) {
-      query.$or = filter.or.map(buildSimpleQuery);
-    }
-
-    // Add AND conditions if present
-    if (filter.and && filter.and.length > 0) {
-      query.$and = filter.and.map(buildSimpleQuery);
-    }
-  }
-
-  const cursor = getPlansCollection().find(query);
-  return await applyQueryOptions(cursor, options).toArray();
-};
-
-export const findPlansByQuery = async (
-  query: Filter<Plan>,
-  options?: PlanQueryOptions,
-): Promise<PlanDoc[]> => {
-  const cursor = getPlansCollection().find(query);
-  return await applyQueryOptions(cursor, options).toArray();
-};
-
-export const countPlans = async (query: Filter<Plan>): Promise<number> => {
-  return getPlansCollection().countDocuments(query);
-};
-
-export const createPlanDoc = async (
-  planData: Omit<Plan, "createdAt" | "updatedAt">,
-): Promise<PlanDoc> => {
-  const now = new Date();
-  const result = await getPlansCollection().insertOne({
-    ...planData,
-    createdAt: now,
-    updatedAt: now,
-  });
-
-  const plans = await findPlans({ _id: result.insertedId });
-  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">>,
-): Promise<PlanDoc | null> => {
-  return await getPlansCollection().findOneAndUpdate(
-    { _id: planId },
-    {
-      $set: {
-        ...updates,
-        updatedAt: new Date(),
-      },
-    },
-    {
-      returnDocument: "after",
-    },
-  );
-};
+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");
+};
+
+/**
+ * Converts a simple filter to MongoDB query format
+ */
+const buildSimpleQuery = (filter: SimplePlanFilter): Filter<Plan> => {
+  const query: Filter<Plan> = {};
+
+  if (filter._id) {
+    query._id = new ObjectId(filter._id);
+  }
+  if (filter.productKey !== undefined) {
+    query.productKey = filter.productKey;
+  }
+  if (filter.isActive !== undefined) {
+    query.isActive = filter.isActive;
+  }
+  if (filter.currency !== undefined) {
+    query.currency = filter.currency;
+  }
+  if (filter.region !== undefined) {
+    query.region = filter.region;
+  }
+  if (filter.countryCode !== undefined) {
+    query.countryCode = filter.countryCode;
+  }
+  if (filter.originalPlanId !== undefined) {
+    query.originalPlanId = filter.originalPlanId;
+  }
+
+  return query;
+};
+
+/**
+ * Generic function to find plans with flexible filtering
+ */
+export const findPlans = async (
+  filter?: PlanFilter,
+  options?: PlanQueryOptions,
+): Promise<PlanDoc[]> => {
+  let query: Filter<Plan> = {};
+
+  if (filter) {
+    // Build the base query from simple filter properties
+    const simpleFilter: SimplePlanFilter = {
+      _id: filter._id,
+      productKey: filter.productKey,
+      isActive: filter.isActive,
+      currency: filter.currency,
+      region: filter.region,
+      countryCode: filter.countryCode,
+      originalPlanId: filter.originalPlanId,
+    };
+
+    // Apply simple filters if any are present
+    const baseQuery = buildSimpleQuery(simpleFilter);
+    if (Object.keys(baseQuery).length > 0) {
+      query = baseQuery;
+    }
+
+    // Add OR conditions if present
+    if (filter.or && filter.or.length > 0) {
+      query.$or = filter.or.map(buildSimpleQuery);
+    }
+
+    // Add AND conditions if present
+    if (filter.and && filter.and.length > 0) {
+      query.$and = filter.and.map(buildSimpleQuery);
+    }
+  }
+
+  const cursor = getPlansCollection().find(query);
+  return await applyQueryOptions(cursor, options).toArray();
+};
+
+export const findPlansByQuery = async (
+  query: Filter<Plan>,
+  options?: PlanQueryOptions,
+): Promise<PlanDoc[]> => {
+  const cursor = getPlansCollection().find(query);
+  return await applyQueryOptions(cursor, options).toArray();
+};
+
+export const countPlans = async (query: Filter<Plan>): Promise<number> => {
+  return getPlansCollection().countDocuments(query);
+};
+
+export const createPlanDoc = async (
+  planData: Omit<Plan, "createdAt" | "updatedAt">,
+): Promise<PlanDoc> => {
+  const now = new Date();
+  const result = await getPlansCollection().insertOne({
+    ...planData,
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  const plans = await findPlans({ _id: result.insertedId });
+  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">>,
+): Promise<PlanDoc | null> => {
+  return await getPlansCollection().findOneAndUpdate(
+    { _id: planId },
+    {
+      $set: {
+        ...updates,
+        updatedAt: new Date(),
+      },
+    },
+    {
+      returnDocument: "after",
+    },
+  );
+};

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

@@ -1,89 +1,89 @@
-import { Sort, ObjectId, WithId } from "mongodb";
-
-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",
-];
-
-/** 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",
-];
-
-/** Logical product family, like "basic-500". Multiple regional variants can share it. */
-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 Tax = {
-  vatIncluded: boolean;
-  vatRatePct: number;
-  countryCode?: CountryCode;
-};
-
-export type Plan = {
-  productKey: ProductKey;
-  name: string;
-  monthlyCallQuota: number;
-  currency: CurrencyCode;
-  priceMonthlyMinor: number;
-  region?: RegionCode;
-  countryCode?: CountryCode;
-  isActive: boolean;
-  isFree?: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-  originalPlanId?: string;
-  tax?: Tax;
-  metadata?: Record<string, unknown>;
-};
-
-export type SimplePlanFilter = {
-  _id?: ObjectId | string;
-  productKey?: ProductKey;
-  isActive?: boolean;
-  currency?: CurrencyCode;
-  region?: RegionCode;
-  countryCode?: CountryCode;
-  originalPlanId?: string;
-};
-
-export type PlanFilter = SimplePlanFilter & {
-  or?: SimplePlanFilter[];
-  and?: SimplePlanFilter[];
-};
-
-export type PlanQueryOptions = {
-  sort?: Sort;
-  skip?: number;
-  limit?: number;
-};
-
-// Convenient aliases
-export type PlanDoc = WithId<Plan>;
-export type Plans = PlanDoc[];
+import { Sort, ObjectId, WithId } from "mongodb";
+
+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",
+];
+
+/** 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",
+];
+
+/** Logical product family, like "basic-500". Multiple regional variants can share it. */
+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 Tax = {
+  vatIncluded: boolean;
+  vatRatePct: number;
+  countryCode?: CountryCode;
+};
+
+export type Plan = {
+  productKey: ProductKey;
+  name: string;
+  monthlyCallQuota: number;
+  currency: CurrencyCode;
+  priceMonthlyMinor: number;
+  region?: RegionCode;
+  countryCode?: CountryCode;
+  isActive: boolean;
+  isFree?: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+  originalPlanId?: string;
+  tax?: Tax;
+  metadata?: Record<string, unknown>;
+};
+
+export type SimplePlanFilter = {
+  _id?: ObjectId | string;
+  productKey?: ProductKey;
+  isActive?: boolean;
+  currency?: CurrencyCode;
+  region?: RegionCode;
+  countryCode?: CountryCode;
+  originalPlanId?: string;
+};
+
+export type PlanFilter = SimplePlanFilter & {
+  or?: SimplePlanFilter[];
+  and?: SimplePlanFilter[];
+};
+
+export type PlanQueryOptions = {
+  sort?: Sort;
+  skip?: number;
+  limit?: number;
+};
+
+// Convenient aliases
+export type PlanDoc = WithId<Plan>;
+export type Plans = PlanDoc[];

package/src/talkpilot/products/__tests__/products.getters.spec.ts

@@ -1,44 +1,44 @@
-import { getProductsCollection, getAllProducts } from "../products.getters";
-import { ObjectId } from "../../index";
-
-describe("products getters", () => {
-  it('should return the "products" collection', () => {
-    const collection = getProductsCollection();
-    expect(collection.collectionName).toBe("products");
-  });
-
-  it("should return all product documents", async () => {
-    await getProductsCollection().insertMany([
-      { _id: new ObjectId(), name: "Municipal" },
-      { _id: new ObjectId(), name: "Clinics" },
-    ]);
-
-    const results = await getAllProducts();
-    expect(results.length).toBeGreaterThanOrEqual(2);
-    expect(results.map((p) => p.name)).toEqual(
-      expect.arrayContaining(["Municipal", "Clinics"]),
-    );
-  });
-
-  it("should store and retrieve displayName locale map", async () => {
-    const id = new ObjectId();
-    await getProductsCollection().insertOne({
-      _id: id,
-      name: "Municipal",
-      displayName: { he: "עירייה", en: "Municipal" },
-    });
-
-    const results = await getAllProducts();
-    const saved = results.find((p) => p._id.equals(id));
-    expect(saved?.displayName).toEqual({ he: "עירייה", en: "Municipal" });
-  });
-
-  it("should return products without displayName without error", async () => {
-    const id = new ObjectId();
-    await getProductsCollection().insertOne({ _id: id, name: "Rcure" });
-
-    const results = await getAllProducts();
-    const saved = results.find((p) => p._id.equals(id));
-    expect(saved?.displayName).toBeUndefined();
-  });
-});
+import { getProductsCollection, getAllProducts } from "../products.getters";
+import { ObjectId } from "../../index";
+
+describe("products getters", () => {
+  it('should return the "products" collection', () => {
+    const collection = getProductsCollection();
+    expect(collection.collectionName).toBe("products");
+  });
+
+  it("should return all product documents", async () => {
+    await getProductsCollection().insertMany([
+      { _id: new ObjectId(), name: "Municipal" },
+      { _id: new ObjectId(), name: "Clinics" },
+    ]);
+
+    const results = await getAllProducts();
+    expect(results.length).toBeGreaterThanOrEqual(2);
+    expect(results.map((p) => p.name)).toEqual(
+      expect.arrayContaining(["Municipal", "Clinics"]),
+    );
+  });
+
+  it("should store and retrieve displayName locale map", async () => {
+    const id = new ObjectId();
+    await getProductsCollection().insertOne({
+      _id: id,
+      name: "Municipal",
+      displayName: { he: "עירייה", en: "Municipal" },
+    });
+
+    const results = await getAllProducts();
+    const saved = results.find((p) => p._id.equals(id));
+    expect(saved?.displayName).toEqual({ he: "עירייה", en: "Municipal" });
+  });
+
+  it("should return products without displayName without error", async () => {
+    const id = new ObjectId();
+    await getProductsCollection().insertOne({ _id: id, name: "Rcure" });
+
+    const results = await getAllProducts();
+    const saved = results.find((p) => p._id.equals(id));
+    expect(saved?.displayName).toBeUndefined();
+  });
+});