@talkpilot/core-db 1.3.6 → 1.3.7

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,45 +1,45 @@
-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();
+  });
+
+});

package/src/talkpilot/products/index.ts

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

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

@@ -1,12 +1,12 @@
-import { Collection, WithId } from "mongodb";
-import { getDb } from "../index";
-import type { Product } from "./products.types";
-
-export const getProductsCollection = (): Collection<Product> => {
-  return getDb().collection<Product>("products");
-};
-
-/** Returns all product documents */
-export const getAllProducts = (): Promise<WithId<Product>[]> => {
-  return getProductsCollection().find().toArray();
-};
+import { Collection, WithId } from "mongodb";
+import { getDb } from "../index";
+import type { Product } from "./products.types";
+
+export const getProductsCollection = (): Collection<Product> => {
+  return getDb().collection<Product>("products");
+};
+
+/** Returns all product documents */
+export const getAllProducts = (): Promise<WithId<Product>[]> => {
+  return getProductsCollection().find().toArray();
+};

package/src/talkpilot/products/products.types.ts

@@ -1,9 +1,9 @@
-import { ObjectId } from "mongodb";
-
-export type Product = {
-  _id: ObjectId;
-  /** Internal product name */
-  name: string;
-  /** Map from language name to display name, e.g. {en, Municipal} */
-  displayName?: Record<string, string>;
-};
+import { ObjectId } from "mongodb";
+
+export type Product = {
+  _id: ObjectId;
+  /** Internal product name */
+  name: string;
+  /** Map from language name to display name, e.g. {en, Municipal} */
+  displayName?: Record<string, string>;
+};

package/src/talkpilot/results/index.ts

@@ -1,7 +1,7 @@
-export {
-  getResultsCollection,
-  initializeResultDocument,
-  findResultById,
-  findResultByCallSid,
-} from "./results.getter";
-export type * from "./results.types";
+export {
+  getResultsCollection,
+  initializeResultDocument,
+  findResultById,
+  findResultByCallSid,
+} from "./results.getter";
+export type * from "./results.types";