@talkpilot/core-db 1.3.49 → 1.3.51

package/src/talkpilot/subscriptions/subscriptions.getters.ts

@@ -1,146 +1,146 @@
-import { getDb } from "../index";
-import {
-  SimpleSubscriptionFilter,
-  Subscription,
-  SubscriptionDoc,
-  SubscriptionFilter,
-  SubscriptionQueryOptions,
-} from "./subscriptions.types";
-import { Filter, ObjectId } from "mongodb";
-import { buildSimpleQuery } from "./subscriptions.getters.utils";
-import { applyQueryOptions } from "../utils/query.utils";
-
-export const getSubscriptionsCollection = () => {
-  return getDb().collection<Subscription>("subscriptions");
-};
-
-/**
- * A simple filter for Subscription: each field may be a value or a MongoDB operator expression
- */
-
-export const findSubscriptions = async (
-  filter?: SubscriptionFilter,
-  options?: SubscriptionQueryOptions,
-): Promise<SubscriptionDoc[]> => {
-  let query: Filter<Subscription> = {};
-
-  if (filter) {
-    const simpleFilter: SimpleSubscriptionFilter = {
-      _id: filter._id,
-      clientId: filter.clientId,
-      planId: filter.planId,
-      startDate: filter.startDate,
-      endDate: filter.endDate,
-      isActive: filter.isActive,
-      createdAt: filter.createdAt,
-      nextRenewalDate: filter.nextRenewalDate,
-    };
-    const baseQuery = buildSimpleQuery(simpleFilter);
-    if (Object.keys(baseQuery).length > 0) {
-      query = baseQuery;
-    }
-    if (filter.or && filter.or.length > 0) {
-      query.$or = filter.or.map(buildSimpleQuery);
-    }
-    if (filter.and && filter.and.length > 0) {
-      query.$and = filter.and.map(buildSimpleQuery);
-    }
-  }
-
-  const cursor = getSubscriptionsCollection().find(query);
-  return await applyQueryOptions(cursor, options).toArray();
-};
-
-export const countSubscriptions = async (
-  query: Filter<Subscription>,
-): Promise<number> => {
-  return getSubscriptionsCollection().countDocuments(query);
-};
-
-export const createSubscriptionDoc = async (
-  subscriptionData: Omit<Subscription, "createdAt" | "updatedAt">,
-): Promise<SubscriptionDoc> => {
-  const now = new Date();
-  const result = await getSubscriptionsCollection().insertOne({
-    ...subscriptionData,
-    createdAt: now,
-    updatedAt: now,
-  });
-
-  const subscriptions = await findSubscriptions({ _id: result.insertedId });
-  if (!subscriptions[0])
-    throw new Error("Failed to retrieve created subscription");
-  return subscriptions[0];
-};
-
-export const updateSubscriptionDoc = async (
-  subscriptionId: ObjectId,
-  updates: Partial<Subscription>,
-): Promise<SubscriptionDoc | null> => {
-  return await getSubscriptionsCollection().findOneAndUpdate(
-    { _id: subscriptionId },
-    {
-      $set: {
-        ...updates,
-        updatedAt: new Date(),
-      },
-    },
-    {
-      returnDocument: "after",
-    },
-  );
-};
-
-export const incrementSubscriptionUsage = async (
-  subscriptionId: ObjectId,
-  amount: number = 1,
-): Promise<SubscriptionDoc | null> => {
-  const fieldToIncrement = "cycles.$[activeCycle].usage.usedCalls";
-  return await getSubscriptionsCollection().findOneAndUpdate(
-    { _id: subscriptionId, "cycles.isActive": true },
-    {
-      $inc: { [fieldToIncrement]: amount },
-      $set: { updatedAt: new Date() },
-    },
-    {
-      arrayFilters: [{ "activeCycle.isActive": true }],
-      returnDocument: "after",
-    },
-  );
-};
-
-export const deactivateCurrentSubscriptionCycle = async (
-  subscriptionId: ObjectId,
-  nextRenewalDate: Date,
-): Promise<void> => {
-  await getSubscriptionsCollection().updateOne(
-    { _id: subscriptionId, "cycles.isActive": true },
-    {
-      $set: {
-        "cycles.$[activeCycle].isActive": false,
-        nextRenewalDate: nextRenewalDate,
-        updatedAt: new Date(),
-      },
-    },
-    {
-      arrayFilters: [{ "activeCycle.isActive": true }],
-    },
-  );
-};
-
-export const pushNewSubscriptionCycle = async (
-  subscriptionId: ObjectId,
-  newCycle: Subscription["cycles"][number],
-): Promise<SubscriptionDoc | null> => {
-  return await getSubscriptionsCollection().findOneAndUpdate(
-    { _id: subscriptionId },
-    {
-      $push: {
-        cycles: newCycle,
-      },
-    },
-    {
-      returnDocument: "after",
-    },
-  );
-};
+import { getDb } from "../index";
+import {
+  SimpleSubscriptionFilter,
+  Subscription,
+  SubscriptionDoc,
+  SubscriptionFilter,
+  SubscriptionQueryOptions,
+} from "./subscriptions.types";
+import { Filter, ObjectId } from "mongodb";
+import { buildSimpleQuery } from "./subscriptions.getters.utils";
+import { applyQueryOptions } from "../utils/query.utils";
+
+export const getSubscriptionsCollection = () => {
+  return getDb().collection<Subscription>("subscriptions");
+};
+
+/**
+ * A simple filter for Subscription: each field may be a value or a MongoDB operator expression
+ */
+
+export const findSubscriptions = async (
+  filter?: SubscriptionFilter,
+  options?: SubscriptionQueryOptions,
+): Promise<SubscriptionDoc[]> => {
+  let query: Filter<Subscription> = {};
+
+  if (filter) {
+    const simpleFilter: SimpleSubscriptionFilter = {
+      _id: filter._id,
+      clientId: filter.clientId,
+      planId: filter.planId,
+      startDate: filter.startDate,
+      endDate: filter.endDate,
+      isActive: filter.isActive,
+      createdAt: filter.createdAt,
+      nextRenewalDate: filter.nextRenewalDate,
+    };
+    const baseQuery = buildSimpleQuery(simpleFilter);
+    if (Object.keys(baseQuery).length > 0) {
+      query = baseQuery;
+    }
+    if (filter.or && filter.or.length > 0) {
+      query.$or = filter.or.map(buildSimpleQuery);
+    }
+    if (filter.and && filter.and.length > 0) {
+      query.$and = filter.and.map(buildSimpleQuery);
+    }
+  }
+
+  const cursor = getSubscriptionsCollection().find(query);
+  return await applyQueryOptions(cursor, options).toArray();
+};
+
+export const countSubscriptions = async (
+  query: Filter<Subscription>,
+): Promise<number> => {
+  return getSubscriptionsCollection().countDocuments(query);
+};
+
+export const createSubscriptionDoc = async (
+  subscriptionData: Omit<Subscription, "createdAt" | "updatedAt">,
+): Promise<SubscriptionDoc> => {
+  const now = new Date();
+  const result = await getSubscriptionsCollection().insertOne({
+    ...subscriptionData,
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  const subscriptions = await findSubscriptions({ _id: result.insertedId });
+  if (!subscriptions[0])
+    throw new Error("Failed to retrieve created subscription");
+  return subscriptions[0];
+};
+
+export const updateSubscriptionDoc = async (
+  subscriptionId: ObjectId,
+  updates: Partial<Subscription>,
+): Promise<SubscriptionDoc | null> => {
+  return await getSubscriptionsCollection().findOneAndUpdate(
+    { _id: subscriptionId },
+    {
+      $set: {
+        ...updates,
+        updatedAt: new Date(),
+      },
+    },
+    {
+      returnDocument: "after",
+    },
+  );
+};
+
+export const incrementSubscriptionUsage = async (
+  subscriptionId: ObjectId,
+  amount: number = 1,
+): Promise<SubscriptionDoc | null> => {
+  const fieldToIncrement = "cycles.$[activeCycle].usage.usedCalls";
+  return await getSubscriptionsCollection().findOneAndUpdate(
+    { _id: subscriptionId, "cycles.isActive": true },
+    {
+      $inc: { [fieldToIncrement]: amount },
+      $set: { updatedAt: new Date() },
+    },
+    {
+      arrayFilters: [{ "activeCycle.isActive": true }],
+      returnDocument: "after",
+    },
+  );
+};
+
+export const deactivateCurrentSubscriptionCycle = async (
+  subscriptionId: ObjectId,
+  nextRenewalDate: Date,
+): Promise<void> => {
+  await getSubscriptionsCollection().updateOne(
+    { _id: subscriptionId, "cycles.isActive": true },
+    {
+      $set: {
+        "cycles.$[activeCycle].isActive": false,
+        nextRenewalDate: nextRenewalDate,
+        updatedAt: new Date(),
+      },
+    },
+    {
+      arrayFilters: [{ "activeCycle.isActive": true }],
+    },
+  );
+};
+
+export const pushNewSubscriptionCycle = async (
+  subscriptionId: ObjectId,
+  newCycle: Subscription["cycles"][number],
+): Promise<SubscriptionDoc | null> => {
+  return await getSubscriptionsCollection().findOneAndUpdate(
+    { _id: subscriptionId },
+    {
+      $push: {
+        cycles: newCycle,
+      },
+    },
+    {
+      returnDocument: "after",
+    },
+  );
+};

package/src/talkpilot/subscriptions/subscriptions.getters.utils.ts

@@ -1,33 +1,33 @@
-import { ObjectId, Filter } from "mongodb";
-import {
-  Subscription,
-  SimpleSubscriptionFilter,
-  simpleFields,
-  SimpleField,
-} from "../index";
-
-export const buildSimpleQuery = (
-  filter: SimpleSubscriptionFilter,
-): Filter<Subscription> => {
-  const query: Filter<Subscription> = {};
-
-  if (filter._id) {
-    query._id = new ObjectId(filter._id);
-  }
-
-  simpleFields.forEach((field: SimpleField) => {
-    const val = filter[field];
-    if (val !== undefined) {
-      query[field] = val as any;
-    }
-  });
-
-  return query;
-};
-
-export const buildDateRangeFilter = (from: Date, to: Date) => {
-  return {
-    $gte: from,
-    $lt: to,
-  };
-};
+import { ObjectId, Filter } from "mongodb";
+import {
+  Subscription,
+  SimpleSubscriptionFilter,
+  simpleFields,
+  SimpleField,
+} from "../index";
+
+export const buildSimpleQuery = (
+  filter: SimpleSubscriptionFilter,
+): Filter<Subscription> => {
+  const query: Filter<Subscription> = {};
+
+  if (filter._id) {
+    query._id = new ObjectId(filter._id);
+  }
+
+  simpleFields.forEach((field: SimpleField) => {
+    const val = filter[field];
+    if (val !== undefined) {
+      query[field] = val as any;
+    }
+  });
+
+  return query;
+};
+
+export const buildDateRangeFilter = (from: Date, to: Date) => {
+  return {
+    $gte: from,
+    $lt: to,
+  };
+};

package/src/talkpilot/subscriptions/subscriptions.types.ts

@@ -1,66 +1,66 @@
-import { Filter, ObjectId, WithId, Sort } from "mongodb";
-import { PlanDoc } from "../plans";
-
-export type SubscriptionCycle = {
-  usage: {
-    usedCalls: number;
-  };
-  startDate: Date;
-  endDate: Date;
-  cycleNumber: number;
-  isActive: boolean;
-};
-
-export type Subscription = {
-  clientId: string;
-  planId: string;
-  planSnapshot: PlanDoc;
-  startDate: Date;
-  endDate?: Date; // optional, if we want to predefine the end date
-  isActive: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-  nextRenewalDate: Date;
-  cycles: SubscriptionCycle[];
-};
-
-export type SubscriptionDoc = WithId<Subscription>;
-export type Subscriptions = SubscriptionDoc[];
-
-// Define which Subscription fields we allow in a simple filter
-export const simpleFields = [
-  "clientId",
-  "planId",
-  "startDate",
-  "endDate",
-  "isActive",
-  "createdAt",
-  "nextRenewalDate",
-] as const;
-export type SimpleField = (typeof simpleFields)[number];
-
-/**
- * A simple filter for Subscription: each field may be a literal or a MongoDB operator
- */
-export type SimpleSubscriptionFilter = {
-  _id?: ObjectId | string;
-} & {
-  [K in keyof Subscription]?: Filter<Subscription>[K];
-};
-
-/**
- * Composite filter allowing nested OR/AND arrays
- */
-export type SubscriptionFilter = SimpleSubscriptionFilter & {
-  or?: SimpleSubscriptionFilter[];
-  and?: SimpleSubscriptionFilter[];
-};
-
-/**
- * Query options for sorting and limiting results
- */
-export type SubscriptionQueryOptions = {
-  sort?: Sort;
-  skip?: number;
-  limit?: number;
-};
+import { Filter, ObjectId, WithId, Sort } from "mongodb";
+import { PlanDoc } from "../plans";
+
+export type SubscriptionCycle = {
+  usage: {
+    usedCalls: number;
+  };
+  startDate: Date;
+  endDate: Date;
+  cycleNumber: number;
+  isActive: boolean;
+};
+
+export type Subscription = {
+  clientId: string;
+  planId: string;
+  planSnapshot: PlanDoc;
+  startDate: Date;
+  endDate?: Date; // optional, if we want to predefine the end date
+  isActive: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+  nextRenewalDate: Date;
+  cycles: SubscriptionCycle[];
+};
+
+export type SubscriptionDoc = WithId<Subscription>;
+export type Subscriptions = SubscriptionDoc[];
+
+// Define which Subscription fields we allow in a simple filter
+export const simpleFields = [
+  "clientId",
+  "planId",
+  "startDate",
+  "endDate",
+  "isActive",
+  "createdAt",
+  "nextRenewalDate",
+] as const;
+export type SimpleField = (typeof simpleFields)[number];
+
+/**
+ * A simple filter for Subscription: each field may be a literal or a MongoDB operator
+ */
+export type SimpleSubscriptionFilter = {
+  _id?: ObjectId | string;
+} & {
+  [K in keyof Subscription]?: Filter<Subscription>[K];
+};
+
+/**
+ * Composite filter allowing nested OR/AND arrays
+ */
+export type SubscriptionFilter = SimpleSubscriptionFilter & {
+  or?: SimpleSubscriptionFilter[];
+  and?: SimpleSubscriptionFilter[];
+};
+
+/**
+ * Query options for sorting and limiting results
+ */
+export type SubscriptionQueryOptions = {
+  sort?: Sort;
+  skip?: number;
+  limit?: number;
+};

package/src/talkpilot/utils/__tests__/query.utils.spec.ts

@@ -1,49 +1,49 @@
-import { applyQueryOptions } from "../query.utils";
-
-describe("query.utils", () => {
-  describe("applyQueryOptions()", () => {
-    let mockCursor: any;
-
-    beforeEach(() => {
-      mockCursor = {
-        sort: jest.fn().mockReturnThis(),
-        skip: jest.fn().mockReturnThis(),
-        limit: jest.fn().mockReturnThis(),
-      };
-    });
-
-    it("should return cursor if no options provided", () => {
-      const result = applyQueryOptions(mockCursor);
-      expect(result).toBe(mockCursor);
-      expect(mockCursor.sort).not.toHaveBeenCalled();
-    });
-
-    it("should apply sort, skip, and limit", () => {
-      const options = {
-        sort: { name: 1 },
-        skip: 10,
-        limit: 5,
-      };
-
-      const result = applyQueryOptions(mockCursor, options);
-
-      expect(result).toBe(mockCursor);
-      expect(mockCursor.sort).toHaveBeenCalledWith({ name: 1 });
-      expect(mockCursor.skip).toHaveBeenCalledWith(10);
-      expect(mockCursor.limit).toHaveBeenCalledWith(5);
-    });
-
-    it("should apply only sort if skip and limit are missing", () => {
-      const options = {
-        sort: { name: 1 },
-      };
-
-      const result = applyQueryOptions(mockCursor, options);
-
-      expect(result).toBe(mockCursor);
-      expect(mockCursor.sort).toHaveBeenCalledWith({ name: 1 });
-      expect(mockCursor.skip).not.toHaveBeenCalled();
-      expect(mockCursor.limit).not.toHaveBeenCalled();
-    });
-  });
-});
+import { applyQueryOptions } from "../query.utils";
+
+describe("query.utils", () => {
+  describe("applyQueryOptions()", () => {
+    let mockCursor: any;
+
+    beforeEach(() => {
+      mockCursor = {
+        sort: jest.fn().mockReturnThis(),
+        skip: jest.fn().mockReturnThis(),
+        limit: jest.fn().mockReturnThis(),
+      };
+    });
+
+    it("should return cursor if no options provided", () => {
+      const result = applyQueryOptions(mockCursor);
+      expect(result).toBe(mockCursor);
+      expect(mockCursor.sort).not.toHaveBeenCalled();
+    });
+
+    it("should apply sort, skip, and limit", () => {
+      const options = {
+        sort: { name: 1 },
+        skip: 10,
+        limit: 5,
+      };
+
+      const result = applyQueryOptions(mockCursor, options);
+
+      expect(result).toBe(mockCursor);
+      expect(mockCursor.sort).toHaveBeenCalledWith({ name: 1 });
+      expect(mockCursor.skip).toHaveBeenCalledWith(10);
+      expect(mockCursor.limit).toHaveBeenCalledWith(5);
+    });
+
+    it("should apply only sort if skip and limit are missing", () => {
+      const options = {
+        sort: { name: 1 },
+      };
+
+      const result = applyQueryOptions(mockCursor, options);
+
+      expect(result).toBe(mockCursor);
+      expect(mockCursor.sort).toHaveBeenCalledWith({ name: 1 });
+      expect(mockCursor.skip).not.toHaveBeenCalled();
+      expect(mockCursor.limit).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/talkpilot/utils/query.utils.ts

@@ -1,21 +1,21 @@
-import { FindCursor } from "mongodb";
-
-export type QueryOptions = {
-  sort?: any;
-  skip?: number;
-  limit?: number;
-};
-
-export const applyQueryOptions = <T>(
-  cursor: FindCursor<T>,
-  options?: QueryOptions,
-): FindCursor<T> => {
-  if (!options) return cursor;
-
-  let result = cursor;
-  if (options.sort) result = result.sort(options.sort);
-  if (options.skip) result = result.skip(options.skip);
-  if (options.limit) result = result.limit(options.limit);
-
-  return result;
-};
+import { FindCursor } from "mongodb";
+
+export type QueryOptions = {
+  sort?: any;
+  skip?: number;
+  limit?: number;
+};
+
+export const applyQueryOptions = <T>(
+  cursor: FindCursor<T>,
+  options?: QueryOptions,
+): FindCursor<T> => {
+  if (!options) return cursor;
+
+  let result = cursor;
+  if (options.sort) result = result.sort(options.sort);
+  if (options.skip) result = result.skip(options.skip);
+  if (options.limit) result = result.limit(options.limit);
+
+  return result;
+};