@talkpilot/core-db 1.1.8 → 1.1.10

package/src/talkpilot/sessions/sessions.types.ts

@@ -1,4 +1,4 @@
-import { ObjectId } from 'mongodb';
+import { ObjectId } from "mongodb";
 
 export type Session = {
   _id?: ObjectId;
@@ -16,7 +16,7 @@ export type Session = {
   phone_numbers: Array<{
     name: string;
     phoneNumber: string;
-    gender: 'male' | 'female';
+    gender: "male" | "female";
   }>;
 
   voice?: string | null;

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

@@ -1,37 +1,40 @@
-import { ObjectId } from 'mongodb';
-import { buildSimpleQuery, buildDateRangeFilter } from '../subscriptions.getters.utils';
-import { SimpleSubscriptionFilter } from '../subscriptions.types';
+import { ObjectId } from "mongodb";
+import {
+  buildSimpleQuery,
+  buildDateRangeFilter,
+} from "../subscriptions.getters.utils";
+import { SimpleSubscriptionFilter } from "../subscriptions.types";
 
-describe('subscriptions.getters.utils', () => {
-  describe('buildSimpleQuery', () => {
-    it('returns empty query when filter is empty', () => {
+describe("subscriptions.getters.utils", () => {
+  describe("buildSimpleQuery", () => {
+    it("returns empty query when filter is empty", () => {
       const filter: SimpleSubscriptionFilter = {};
       const result = buildSimpleQuery(filter);
       expect(result).toEqual({});
     });
 
-    it('converts _id string to ObjectId', () => {
-      const id = '507f1f77bcf86cd799439011';
+    it("converts _id string to ObjectId", () => {
+      const id = "507f1f77bcf86cd799439011";
       const filter: SimpleSubscriptionFilter = { _id: id };
       const result = buildSimpleQuery(filter);
       expect(result._id).toBeInstanceOf(ObjectId);
       expect((result._id as ObjectId).toHexString()).toBe(id);
     });
 
-    it('includes valid simple fields', () => {
+    it("includes valid simple fields", () => {
       const filter: SimpleSubscriptionFilter = {
-        clientId: 'abc',
+        clientId: "abc",
         isActive: true,
       };
       const result = buildSimpleQuery(filter);
-      expect(result).toEqual({ clientId: 'abc', isActive: true });
+      expect(result).toEqual({ clientId: "abc", isActive: true });
     });
   });
 
-  describe('buildDateRangeFilter', () => {
-    it('returns a mongo date range filter', () => {
-      const from = new Date('2023-01-01');
-      const to = new Date('2023-01-02');
+  describe("buildDateRangeFilter", () => {
+    it("returns a mongo date range filter", () => {
+      const from = new Date("2023-01-01");
+      const to = new Date("2023-01-02");
       const result = buildDateRangeFilter(from, to);
       expect(result).toEqual({
         $gte: from,

package/src/talkpilot/subscriptions/index.ts

@@ -1,3 +1,3 @@
-export * from './subscriptions.types';
-export * from './subscriptions.getters';
-export * from './subscriptions.getters.utils';
+export * from "./subscriptions.types";
+export * from "./subscriptions.getters";
+export * from "./subscriptions.getters.utils";

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

@@ -1,17 +1,17 @@
-import {getDb} from '../index';
+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';
+} 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');
+  return getDb().collection<Subscription>("subscriptions");
 };
 
 /**
@@ -20,7 +20,7 @@ export const getSubscriptionsCollection = () => {
 
 export const findSubscriptions = async (
   filter?: SubscriptionFilter,
-  options?: SubscriptionQueryOptions
+  options?: SubscriptionQueryOptions,
 ): Promise<SubscriptionDoc[]> => {
   let query: Filter<Subscription> = {};
 
@@ -51,12 +51,14 @@ export const findSubscriptions = async (
   return await applyQueryOptions(cursor, options).toArray();
 };
 
-export const countSubscriptions = async (query: Filter<Subscription>): Promise<number> => {
+export const countSubscriptions = async (
+  query: Filter<Subscription>,
+): Promise<number> => {
   return getSubscriptionsCollection().countDocuments(query);
 };
 
 export const createSubscriptionDoc = async (
-  subscriptionData: Omit<Subscription, 'createdAt' | 'updatedAt'>
+  subscriptionData: Omit<Subscription, "createdAt" | "updatedAt">,
 ): Promise<SubscriptionDoc> => {
   const now = new Date();
   const result = await getSubscriptionsCollection().insertOne({
@@ -66,13 +68,14 @@ export const createSubscriptionDoc = async (
   });
 
   const subscriptions = await findSubscriptions({ _id: result.insertedId });
-  if (!subscriptions[0]) throw new Error('Failed to retrieve created subscription');
+  if (!subscriptions[0])
+    throw new Error("Failed to retrieve created subscription");
   return subscriptions[0];
 };
 
 export const updateSubscriptionDoc = async (
   subscriptionId: ObjectId,
-  updates: Partial<Subscription>
+  updates: Partial<Subscription>,
 ): Promise<SubscriptionDoc | null> => {
   return await getSubscriptionsCollection().findOneAndUpdate(
     { _id: subscriptionId },
@@ -83,61 +86,61 @@ export const updateSubscriptionDoc = async (
       },
     },
     {
-      returnDocument: 'after',
-    }
+      returnDocument: "after",
+    },
   );
 };
 
 export const incrementSubscriptionUsage = async (
   subscriptionId: ObjectId,
-  amount: number = 1
+  amount: number = 1,
 ): Promise<SubscriptionDoc | null> => {
-  const fieldToIncrement = 'cycles.$[activeCycle].usage.usedCalls';
+  const fieldToIncrement = "cycles.$[activeCycle].usage.usedCalls";
   return await getSubscriptionsCollection().findOneAndUpdate(
-    { _id: subscriptionId, 'cycles.isActive': true },
+    { _id: subscriptionId, "cycles.isActive": true },
     {
       $inc: { [fieldToIncrement]: amount },
       $set: { updatedAt: new Date() },
     },
     {
-      arrayFilters: [{ 'activeCycle.isActive': true }],
-      returnDocument: 'after',
-    }
+      arrayFilters: [{ "activeCycle.isActive": true }],
+      returnDocument: "after",
+    },
   );
 };
 
 export const deactivateCurrentSubscriptionCycle = async (
   subscriptionId: ObjectId,
-  nextRenewalDate: Date
+  nextRenewalDate: Date,
 ): Promise<void> => {
   await getSubscriptionsCollection().updateOne(
-    { _id: subscriptionId, 'cycles.isActive': true },
+    { _id: subscriptionId, "cycles.isActive": true },
     {
       $set: {
-        'cycles.$[activeCycle].isActive': false,
+        "cycles.$[activeCycle].isActive": false,
         nextRenewalDate: nextRenewalDate,
         updatedAt: new Date(),
       },
     },
     {
-      arrayFilters: [{ 'activeCycle.isActive': true }],
-    }
+      arrayFilters: [{ "activeCycle.isActive": true }],
+    },
   );
 };
 
 export const pushNewSubscriptionCycle = async (
   subscriptionId: ObjectId,
-  newCycle: Subscription['cycles'][number]
+  newCycle: Subscription["cycles"][number],
 ): Promise<SubscriptionDoc | null> => {
   return await getSubscriptionsCollection().findOneAndUpdate(
-      {_id: subscriptionId},
-      {
-        $push: {
-          cycles: newCycle,
-        },
+    { _id: subscriptionId },
+    {
+      $push: {
+        cycles: newCycle,
       },
-      {
-        returnDocument: 'after',
-      }
+    },
+    {
+      returnDocument: "after",
+    },
   );
 };

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

@@ -1,7 +1,14 @@
-import { ObjectId, Filter } from 'mongodb';
-import { Subscription, SimpleSubscriptionFilter, simpleFields, SimpleField } from '../index';
+import { ObjectId, Filter } from "mongodb";
+import {
+  Subscription,
+  SimpleSubscriptionFilter,
+  simpleFields,
+  SimpleField,
+} from "../index";
 
-export const buildSimpleQuery = (filter: SimpleSubscriptionFilter): Filter<Subscription> => {
+export const buildSimpleQuery = (
+  filter: SimpleSubscriptionFilter,
+): Filter<Subscription> => {
   const query: Filter<Subscription> = {};
 
   if (filter._id) {

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

@@ -1,5 +1,5 @@
-import { Filter, ObjectId, WithId, Sort } from 'mongodb';
-import { PlanDoc } from '../plans/plans.types';
+import { Filter, ObjectId, WithId, Sort } from "mongodb";
+import { PlanDoc } from "../plans";
 
 export type SubscriptionCycle = {
   usage: {
@@ -29,13 +29,13 @@ export type Subscriptions = SubscriptionDoc[];
 
 // Define which Subscription fields we allow in a simple filter
 export const simpleFields = [
-  'clientId',
-  'planId',
-  'startDate',
-  'endDate',
-  'isActive',
-  'createdAt',
-  'nextRenewalDate',
+  "clientId",
+  "planId",
+  "startDate",
+  "endDate",
+  "isActive",
+  "createdAt",
+  "nextRenewalDate",
 ] as const;
 export type SimpleField = (typeof simpleFields)[number];
 

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

@@ -1,7 +1,7 @@
-import { applyQueryOptions } from '../query.utils';
+import { applyQueryOptions } from "../query.utils";
 
-describe('query.utils', () => {
-  describe('applyQueryOptions()', () => {
+describe("query.utils", () => {
+  describe("applyQueryOptions()", () => {
     let mockCursor: any;
 
     beforeEach(() => {
@@ -12,13 +12,13 @@ describe('query.utils', () => {
       };
     });
 
-    it('should return cursor if no options provided', () => {
+    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', () => {
+    it("should apply sort, skip, and limit", () => {
       const options = {
         sort: { name: 1 },
         skip: 10,
@@ -26,20 +26,20 @@ describe('query.utils', () => {
       };
 
       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', () => {
+    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();

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

@@ -1,4 +1,4 @@
-import { FindCursor } from 'mongodb';
+import { FindCursor } from "mongodb";
 
 export type QueryOptions = {
   sort?: any;
@@ -8,7 +8,7 @@ export type QueryOptions = {
 
 export const applyQueryOptions = <T>(
   cursor: FindCursor<T>,
-  options?: QueryOptions
+  options?: QueryOptions,
 ): FindCursor<T> => {
   if (!options) return cursor;
 

package/src/test-utils/db-utils.ts

@@ -1,18 +1,18 @@
-import { MongoMemoryServer } from 'mongodb-memory-server';
-import { MongoClient, Db } from 'mongodb';
-import { setDb, setMunicipalDataDb } from '../index';
+import { MongoMemoryServer } from "mongodb-memory-server";
+import { MongoClient, Db } from "mongodb";
+import { setDb, setMunicipalDataDb } from "../index";
 
 let mongoServer: MongoMemoryServer;
 let client: MongoClient;
 
 export async function initTestDb(): Promise<Db> {
   mongoServer = await MongoMemoryServer.create({
-    instance: { ip: '127.0.0.1' },
+    instance: { ip: "127.0.0.1" },
   });
   client = new MongoClient(mongoServer.getUri());
   await client.connect();
   const talkpilotDb = client.db();
-  const municipalDb = client.db('municipal-data');
+  const municipalDb = client.db("municipal-data");
   setDb(talkpilotDb);
   setMunicipalDataDb(municipalDb);
   return talkpilotDb;

package/src/test-utils/factories/index.ts

@@ -1,12 +1,12 @@
-export * from './talkpilot/agents';
-export * from './talkpilot/calls';
-export * from './talkpilot/clientAudioBuffers';
-export * from './talkpilot/clientsConfig';
-export * from './talkpilot/flows';
-export * from './talkpilot/groups';
-export * from './talkpilot/phone_numbers';
-export * from './talkpilot/sessions';
-export * from './municipal/cities';
-export * from './municipal/departmentsSubjects';
-export * from './municipal/streets';
-export * from './municipal/tickets';
+export * from "./talkpilot/agents";
+export * from "./talkpilot/calls";
+export * from "./talkpilot/clientAudioBuffers";
+export * from "./talkpilot/clientsConfig";
+export * from "./talkpilot/flows";
+export * from "./talkpilot/groups";
+export * from "./talkpilot/phone_numbers";
+export * from "./talkpilot/sessions";
+export * from "./municipal/cities";
+export * from "./municipal/departmentsSubjects";
+export * from "./municipal/streets";
+export * from "./municipal/tickets";

package/src/test-utils/factories/municipal/cities.ts

@@ -1,11 +1,11 @@
-import { Factory } from 'fishery';
-import { ObjectId } from 'mongodb';
-import { faker } from '@faker-js/faker';
-import type { City } from '../../../municipal/cities/cities.types';
+import { Factory } from "fishery";
+import { ObjectId } from "mongodb";
+import { faker } from "@faker-js/faker";
+import type { City } from "../../../municipal";
 
 export const cityFactory = Factory.define<City>(() => ({
   _id: new ObjectId(),
-  name: faker.location.city().toLowerCase().replace(/\s/g, '_'),
+  name: faker.location.city().toLowerCase().replace(/\s/g, "_"),
   displayName: faker.location.city(),
   createdAt: new Date(),
   updatedAt: new Date(),

package/src/test-utils/factories/municipal/departmentsSubjects.ts

@@ -1,30 +1,37 @@
-import { Factory } from 'fishery';
-import { ObjectId } from 'mongodb';
-import { faker } from '@faker-js/faker';
-import type {
-  DepartmentSubject,
+import { Factory } from "fishery";
+import { ObjectId } from "mongodb";
+import { faker } from "@faker-js/faker";
+import type { DepartmentSubject } from "../../../municipal";
+import { CityName } from "../../../municipal";
 
-} from '../../../municipal/departmentsSubjects/departmentsSubjects.types';
-import {CityName} from "../../../municipal";
+const VALID_CITIES: CityName[] = [
+  "ashdod",
+  "maltar",
+  "billit",
+  "hashkelon",
+  "tests",
+];
 
-const VALID_CITIES: CityName[] = ['ashdod', 'maltar', 'billit', 'hashkelon', 'tests'];
+export const departmentSubjectFactory = Factory.define<DepartmentSubject>(
+  () => ({
+    _id: new ObjectId(),
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    subjectName: faker.lorem.words(2),
+    subject_id: faker.string.numeric(4),
+    sub_subject_name: faker.lorem.word(),
+    sub_subject_id: faker.string.numeric(4),
+    descriptions: [faker.lorem.sentence()],
+    cityName: faker.helpers.arrayElement(VALID_CITIES),
+    guidelines: null,
+    instructions: [],
+    communications: [],
+    sla: faker.number.int({ min: 24, max: 720 }),
+  }),
+);
 
-export const departmentSubjectFactory = Factory.define<DepartmentSubject>(() => ({
-  _id: new ObjectId(),
-  createdAt: new Date(),
-  updatedAt: new Date(),
-  subjectName: faker.lorem.words(2),
-  subject_id: faker.string.numeric(4),
-  sub_subject_name: faker.lorem.word(),
-  sub_subject_id: faker.string.numeric(4),
-  descriptions: [faker.lorem.sentence()],
-  cityName: faker.helpers.arrayElement(VALID_CITIES),
-  guidelines: null,
-  instructions: [],
-  communications: [],
-  sla: faker.number.int({ min: 24, max: 720 }),
-}));
-
-export function createDepartmentSubject(overrides?: Partial<DepartmentSubject>): DepartmentSubject {
+export function createDepartmentSubject(
+  overrides?: Partial<DepartmentSubject>,
+): DepartmentSubject {
   return departmentSubjectFactory.build(overrides);
 }

package/src/test-utils/factories/municipal/streets.ts

@@ -1,7 +1,7 @@
-import { Factory } from 'fishery';
-import { ObjectId } from 'mongodb';
-import { faker } from '@faker-js/faker';
-import type { Street } from '../../../municipal/streets/streets.types';
+import { Factory } from "fishery";
+import { ObjectId } from "mongodb";
+import { faker } from "@faker-js/faker";
+import type { Street } from "../../../municipal";
 
 export const streetFactory = Factory.define<Street>(() => ({
   _id: new ObjectId(),
@@ -9,7 +9,12 @@ export const streetFactory = Factory.define<Street>(() => ({
   updatedAt: new Date(),
   id: faker.string.uuid(),
   name: faker.location.street(),
-  cityName: faker.helpers.arrayElement(['ashdod', 'maltar', 'billit', 'hashkelon']),
+  cityName: faker.helpers.arrayElement([
+    "ashdod",
+    "maltar",
+    "billit",
+    "hashkelon",
+  ]),
 }));
 
 export function createStreet(overrides?: Partial<Street>): Street {

package/src/test-utils/factories/municipal/tickets.ts

@@ -1,10 +1,16 @@
-import { Factory } from 'fishery';
-import { ObjectId } from 'mongodb';
-import { faker } from '@faker-js/faker';
-import type { Ticket } from '../../../municipal/tickets/tickets.types';
-import {CityName} from "../../../municipal";
+import { Factory } from "fishery";
+import { ObjectId } from "mongodb";
+import { faker } from "@faker-js/faker";
+import type { Ticket } from "../../../municipal";
+import { CityName } from "../../../municipal";
 
-const VALID_CITIES: CityName[] = ['ashdod', 'maltar', 'billit', 'hashkelon', 'tests'];
+const VALID_CITIES: CityName[] = [
+  "ashdod",
+  "maltar",
+  "billit",
+  "hashkelon",
+  "tests",
+];
 
 export const ticketFactory = Factory.define<Ticket>(() => ({
   _id: new ObjectId(),

package/src/test-utils/factories/talkpilot/agents.ts

@@ -1,17 +1,17 @@
-import { Factory } from 'fishery';
-import { ObjectId } from 'mongodb';
-import { faker } from '@faker-js/faker';
-import type { Agent } from '../../../talkpilot/agents/agents.types';
+import { Factory } from "fishery";
+import { ObjectId } from "mongodb";
+import { faker } from "@faker-js/faker";
+import type { Agent } from "../../../talkpilot";
 
 export const agentFactory = Factory.define<Agent>(() => ({
   name: faker.person.fullName(),
-  language: 'en',
-  voice: 'alloy',
+  language: "en",
+  voice: "alloy",
   instructions: faker.lorem.paragraph(),
   labels: [],
   clientId: new ObjectId().toString(),
-  role: 'assistant',
-  gender: faker.helpers.arrayElement(['male', 'female']),
+  role: "assistant",
+  gender: faker.helpers.arrayElement(["male", "female"]),
 }));
 
 export function createAgent(overrides?: Partial<Agent>): Agent {

package/src/test-utils/factories/talkpilot/calls.ts

@@ -1,7 +1,7 @@
-import { Factory } from 'fishery';
-import { ObjectId } from 'mongodb';
-import { faker } from '@faker-js/faker';
-import type { Call } from '../../../talkpilot/calls/calls.types';
+import { Factory } from "fishery";
+import { ObjectId } from "mongodb";
+import { faker } from "@faker-js/faker";
+import type { Call } from "../../../talkpilot";
 
 export const callFactory = Factory.define<Call>(() => ({
   callSid: faker.string.uuid(),
@@ -14,7 +14,7 @@ export const callFactory = Factory.define<Call>(() => ({
   isIncomingCall: false,
   isOutgoingCall: true,
   callLength: faker.number.int({ min: 0, max: 3600 }),
-  env: 'test',
+  env: "test",
   updatedAt: new Date(),
   createdAt: new Date(),
 }));

package/src/test-utils/factories/talkpilot/clientAudioBuffers.ts

@@ -1,18 +1,20 @@
-import { Factory } from 'fishery';
-import { faker } from '@faker-js/faker';
-import { CreateAudioBufferInput } from '../../../talkpilot/clientAudioBuffers/clientsAudioBuffers.types';
+import { Factory } from "fishery";
+import { faker } from "@faker-js/faker";
+import { CreateAudioBufferInput } from "../../../talkpilot";
 
-export const audioBufferInputFactory = Factory.define<CreateAudioBufferInput>(() => ({
-  callSid: 'CA1234567890abcdef1234567890abcdef',
-  clientId: faker.string.uuid(),
-  bucketStartMs: faker.number.int({ min: 0, max: 1000000 }),
-  bucketDurationMs: faker.helpers.arrayElement([500, 1000]),
-  data: Buffer.from(faker.string.alphanumeric({ length: 100 })),
-  ttlMs: faker.number.int({ min: 1000, max: 3600000 }),
-}));
+export const audioBufferInputFactory = Factory.define<CreateAudioBufferInput>(
+  () => ({
+    callSid: "CA1234567890abcdef1234567890abcdef",
+    clientId: faker.string.uuid(),
+    bucketStartMs: faker.number.int({ min: 0, max: 1000000 }),
+    bucketDurationMs: faker.helpers.arrayElement([500, 1000]),
+    data: Buffer.from(faker.string.alphanumeric({ length: 100 })),
+    ttlMs: faker.number.int({ min: 1000, max: 3600000 }),
+  }),
+);
 
 export function createAudioBufferInput(
-  overrides?: Partial<CreateAudioBufferInput>
+  overrides?: Partial<CreateAudioBufferInput>,
 ): CreateAudioBufferInput {
   return audioBufferInputFactory.build(overrides ?? {});
 }

package/src/test-utils/factories/talkpilot/clientsConfig.ts

@@ -1,10 +1,7 @@
-import { Factory } from 'fishery';
-import { ObjectId } from 'mongodb';
-import { faker } from '@faker-js/faker';
-import type {
-  ClientConfig,
-  ClientConfigDoc,
-} from '../../../talkpilot/clientsConfig/clientsConfig.types';
+import { Factory } from "fishery";
+import { ObjectId } from "mongodb";
+import { faker } from "@faker-js/faker";
+import type { ClientConfig, ClientConfigDoc } from "../../../talkpilot";
 
 export const clientConfigFactory = Factory.define<ClientConfigDoc>(() => ({
   _id: new ObjectId(),
@@ -12,7 +9,9 @@ export const clientConfigFactory = Factory.define<ClientConfigDoc>(() => ({
   products: {},
 }));
 
-export function createClientConfig(overrides?: Partial<ClientConfig>): ClientConfigDoc {
+export function createClientConfig(
+  overrides?: Partial<ClientConfig>,
+): ClientConfigDoc {
   return clientConfigFactory.build({
     ...overrides,
   });