@talkpilot/core-db 1.1.3 → 1.1.5

package/src/municipal/departmentsSubjects/departmentsSubjects.getters.ts

@@ -1,10 +1,11 @@
-import { getDb, DepartmentSubject, CityName } from '../index';
-import { Collection, Filter } from 'mongodb';
-import { VectorSearchResult } from './departmentsSubjects.types';
+import { CityName, DepartmentSubject, getDb } from "../index";
+import { Collection, Filter } from "mongodb";
+import { VectorSearchResult } from "./departmentsSubjects.types";
 
-export const getDepartmentsSubjectsCollection = (): Collection<DepartmentSubject> => {
-  return getDb().collection<DepartmentSubject>('departmentsSubjects');
-};
+export const getDepartmentsSubjectsCollection =
+  (): Collection<DepartmentSubject> => {
+    return getDb().collection<DepartmentSubject>("departmentsSubjects");
+  };
 
 /**
  * Get all departments subjects for a given city.
@@ -16,7 +17,7 @@ export const getDepartmentsSubjectsCollection = (): Collection<DepartmentSubject
  */
 export const getAllDepartmentsSubjectsByCity = async (
   cityName: CityName,
-  withEmbeddings: boolean = false
+  withEmbeddings: boolean = false,
 ): Promise<DepartmentSubject[]> => {
   const collection = getDepartmentsSubjectsCollection();
   const query = collection.find({ cityName });
@@ -42,17 +43,17 @@ export const vectorSearchDepartmentsSubjects = async (
   queryVector: number[],
   cityName: CityName,
   limit: number = 5,
-  numCandidates: number = 800
+  numCandidates: number = 800,
 ): Promise<VectorSearchResult[]> => {
   const collection = getDepartmentsSubjectsCollection();
-  const indexName = 'subjectTreesIndex';
+  const indexName = "subjectTreesIndex";
 
-  const results = await collection
+  return await collection
     .aggregate<VectorSearchResult>([
       {
         $vectorSearch: {
           index: indexName,
-          path: 'embedding',
+          path: "embedding",
           queryVector,
           numCandidates,
           limit,
@@ -63,23 +64,21 @@ export const vectorSearchDepartmentsSubjects = async (
         $project: {
           _id: 0,
           subjectName: 1,
-          subject_id: { $toInt: '$subject_id' }, // Convert string to number
+          subject_id: { $toInt: "$subject_id" }, // Convert string to number
           sub_subject_name: 1,
           sub_subject_id: 1,
           descriptions: 1,
           guidelines: 1,
-          score: { $meta: 'vectorSearchScore' },
+          score: { $meta: "vectorSearchScore" },
         },
       },
     ])
     .toArray();
-
-  return results;
 };
 
 export const addDepartmentSubjectInstruction = async (
   filter: Filter<DepartmentSubject>,
-  instructionText: string
+  instructionText: string,
 ): Promise<DepartmentSubject | null> => {
   const newInstruction = {
     id: Date.now(),
@@ -92,7 +91,7 @@ export const addDepartmentSubjectInstruction = async (
       $push: { instructions: newInstruction },
       $set: { updatedAt: new Date() },
     },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
 
   return result || null;
@@ -101,12 +100,17 @@ export const addDepartmentSubjectInstruction = async (
 export const updateDepartmentSubjectInstruction = async (
   filter: Filter<DepartmentSubject>,
   instructionId: number,
-  newInstructionText: string
+  newInstructionText: string,
 ): Promise<DepartmentSubject | null> => {
   const result = await getDepartmentsSubjectsCollection().findOneAndUpdate(
-    { ...filter, 'instructions.id': instructionId },
-    { $set: { 'instructions.$.instruction': newInstructionText, updatedAt: new Date() } },
-    { returnDocument: 'after' }
+    { ...filter, "instructions.id": instructionId },
+    {
+      $set: {
+        "instructions.$.instruction": newInstructionText,
+        updatedAt: new Date(),
+      },
+    },
+    { returnDocument: "after" },
   );
 
   return result || null;
@@ -114,7 +118,7 @@ export const updateDepartmentSubjectInstruction = async (
 
 export const removeDepartmentSubjectInstruction = async (
   filter: Filter<DepartmentSubject>,
-  instructionId: number
+  instructionId: number,
 ): Promise<DepartmentSubject | null> => {
   const result = await getDepartmentsSubjectsCollection().findOneAndUpdate(
     filter,
@@ -122,7 +126,7 @@ export const removeDepartmentSubjectInstruction = async (
       $pull: { instructions: { id: instructionId } },
       $set: { updatedAt: new Date() },
     },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
 
   return result || null;
@@ -131,18 +135,22 @@ export const removeDepartmentSubjectInstruction = async (
 export const addDepartmentSubjectCommunication = async (
   filter: Filter<DepartmentSubject>,
   communication: {
-    type: 'free_text_sms' | 'upload_url_sms';
+    type: "free_text_sms" | "upload_url_sms";
     message_text?: string;
     template_id?: string;
     to?: string;
-  }
+  },
 ): Promise<DepartmentSubject | null> => {
   const newCommunication = {
     id: Date.now(),
     type: communication.type,
-    ...(communication.message_text !== undefined && { message_text: communication.message_text }),
+    ...(communication.message_text !== undefined && {
+      message_text: communication.message_text,
+    }),
     is_deleted: false,
-    ...(communication.template_id !== undefined && { template_id: communication.template_id }),
+    ...(communication.template_id !== undefined && {
+      template_id: communication.template_id,
+    }),
     ...(communication.to !== undefined && { to: communication.to }),
   };
 
@@ -152,7 +160,7 @@ export const addDepartmentSubjectCommunication = async (
       $push: { communications: newCommunication },
       $set: { updatedAt: new Date() },
     },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
 
   return result || null;
@@ -162,27 +170,28 @@ export const updateDepartmentSubjectCommunication = async (
   filter: Filter<DepartmentSubject>,
   communicationId: number,
   updates: {
-    type?: 'free_text_sms' | 'upload_url_sms';
+    type?: "free_text_sms" | "upload_url_sms";
     message_text?: string | null;
     template_id?: string | null;
     to?: string | null;
     is_deleted?: boolean | null;
-  }
+  },
 ): Promise<DepartmentSubject | null> => {
   const setFields: Record<string, unknown> = { updatedAt: new Date() };
-  if (updates.type !== undefined) setFields['communications.$.type'] = updates.type;
+  if (updates.type !== undefined)
+    setFields["communications.$.type"] = updates.type;
   if (updates.message_text !== undefined)
-    setFields['communications.$.message_text'] = updates.message_text;
+    setFields["communications.$.message_text"] = updates.message_text;
   if (updates.template_id !== undefined)
-    setFields['communications.$.template_id'] = updates.template_id;
-  if (updates.to !== undefined) setFields['communications.$.to'] = updates.to;
+    setFields["communications.$.template_id"] = updates.template_id;
+  if (updates.to !== undefined) setFields["communications.$.to"] = updates.to;
   if (updates.is_deleted !== undefined)
-    setFields['communications.$.is_deleted'] = updates.is_deleted;
+    setFields["communications.$.is_deleted"] = updates.is_deleted;
 
   const result = await getDepartmentsSubjectsCollection().findOneAndUpdate(
-    { ...filter, 'communications.id': communicationId },
+    { ...filter, "communications.id": communicationId },
     { $set: setFields },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
 
   return result || null;
@@ -190,7 +199,7 @@ export const updateDepartmentSubjectCommunication = async (
 
 export const removeDepartmentSubjectCommunication = async (
   filter: Filter<DepartmentSubject>,
-  communicationId: number
+  communicationId: number,
 ): Promise<DepartmentSubject | null> => {
   const result = await getDepartmentsSubjectsCollection().findOneAndUpdate(
     filter,
@@ -198,7 +207,7 @@ export const removeDepartmentSubjectCommunication = async (
       $pull: { communications: { id: communicationId } },
       $set: { updatedAt: new Date() },
     },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
 
   return result || null;
@@ -214,7 +223,7 @@ export const removeDepartmentSubjectCommunication = async (
 export const getDepartmentSubjectBySubjectIds = async (
   subjectId: string,
   subSubjectId: string,
-  cityName: CityName
+  cityName: CityName,
 ): Promise<DepartmentSubject | null> => {
   const collection = getDepartmentsSubjectsCollection();
 
@@ -240,13 +249,13 @@ export const getDepartmentSubjectBySubjectIds = async (
  */
 export const updateDepartmentSubjectGuidelines = async (
   filter: Filter<DepartmentSubject>,
-  guidelines: string
+  guidelines: string,
 ): Promise<DepartmentSubject | null> => {
   // $set will create the field if it doesn't exist
   const result = await getDepartmentsSubjectsCollection().findOneAndUpdate(
     filter,
     { $set: { guidelines, updatedAt: new Date() } },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
   return result || null;
 };
@@ -257,13 +266,13 @@ export const updateDepartmentSubjectGuidelines = async (
  * @returns Updated DepartmentSubject document or null if not found
  */
 export const deleteDepartmentSubjectGuidelines = async (
-  filter: Filter<DepartmentSubject>
+  filter: Filter<DepartmentSubject>,
 ): Promise<DepartmentSubject | null> => {
   // $set clears the field by setting it to null (keeps the field in the document)
   const result = await getDepartmentsSubjectsCollection().findOneAndUpdate(
     filter,
     { $set: { guidelines: null, updatedAt: new Date() } },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
   return result || null;
 };

package/src/municipal/departmentsSubjects/departmentsSubjects.types.ts

@@ -1,7 +1,7 @@
-import {ObjectId, WithId} from 'mongodb';
-import {Request} from 'express';
-import {ClientConfigDoc, Products} from '../../talkpilot/clientsConfig/clientsConfig.types';
-import {CityName} from "../utils/types";
+import { ObjectId, WithId } from "mongodb";
+import { Request } from "express";
+import { ClientConfigDoc, Products } from "../../talkpilot";
+import { CityName } from "../utils/types";
 
 export type DepartmentSubject = {
   _id: ObjectId;
@@ -57,7 +57,7 @@ export type VectorSearchResult = {
   score?: number;
 };
 
-export type CommunicationType = 'free_text_sms' | 'upload_url_sms';
+export type CommunicationType = "free_text_sms" | "upload_url_sms";
 
 /**
  * Extended Express Request type with client configuration

package/src/municipal/departmentsSubjects/index.ts

@@ -1,4 +1,4 @@
-export * from './departmentsSubjects.getters';
+export * from "./departmentsSubjects.getters";
 export type {
   DepartmentSubject,
   DepartmentSubjectDoc,
@@ -6,5 +6,4 @@ export type {
   RequestWithClientConfig,
   Communication,
   Instruction,
-} from './departmentsSubjects.types';
-
+} from "./departmentsSubjects.types";

package/src/municipal/index.ts

@@ -1,13 +1,13 @@
-import { Db, ObjectId as MongoObjectId } from 'mongodb';
+import { Db, ObjectId as MongoObjectId } from "mongodb";
 
-export * from './cities';
-export * from './streets';
-export * from './departmentsSubjects';
-export * from './tickets';
-export * from './systemInstructions';
-export * from './utils/types';
-export {CityName} from "./utils/types";
-export { municipalDataMongodbClient } from './mongodb-client';
+export * from "./cities";
+export * from "./streets";
+export * from "./departmentsSubjects";
+export * from "./tickets";
+export * from "./systemInstructions";
+export * from "./utils/types";
+export { CityName } from "./utils/types";
+export { municipalDataMongodbClient } from "./mongodb-client";
 
 let db: Db;
 export const setDb = (d: Db) => {
@@ -15,7 +15,7 @@ export const setDb = (d: Db) => {
 };
 
 export const getDb = (): Db => {
-  if (!db) throw new Error('Municipal Data DB not initialised');
+  if (!db) throw new Error("Municipal Data DB not initialised");
   return db;
 };
 export const ObjectId = MongoObjectId;

package/src/municipal/mongodb-client.ts

@@ -1,11 +1,11 @@
-import { MongoClient, Db } from 'mongodb';
-import { setDb } from './index';
-import { validateConfig, validateMongoUri } from '../utils/validation';
+import { MongoClient, Db } from "mongodb";
+import { setDb } from "./index";
+import { validateConfig, validateMongoUri } from "../utils/validation";
 
 class MunicipalDataMongoDBClient {
   private client: MongoClient | null = null;
   private db: Db | null = null;
-  private readonly defaultDbName = 'municipal-data';
+  private readonly defaultDbName = "municipal-data";
 
   async connect(uri?: string, dbName?: string): Promise<void> {
     if (this.client) {
@@ -13,39 +13,32 @@ class MunicipalDataMongoDBClient {
     }
 
     const mongodbUri = uri || process.env.MONGO_URI || process.env.MONGODB_URI;
-    validateConfig('MONGO_URI', mongodbUri);
+    validateConfig("MONGO_URI", mongodbUri);
     validateMongoUri(mongodbUri!);
 
-    try {
-      this.client = new MongoClient(mongodbUri!);
-      await this.client.connect();
-      const targetDbName = dbName || this.defaultDbName;
-      this.db = this.client.db(targetDbName);
-      setDb(this.db);
-      console.info(`[core-db] Municipal MongoDB connected: ${targetDbName}`);
-    } catch (error) {
-      console.error('[core-db] Municipal connection failed', error as Error);
-      throw error;
-    }
+    this.client = new MongoClient(mongodbUri!);
+    await this.client.connect();
+    const targetDbName =
+      dbName || process.env.MUNICIPAL_DB_NAME || this.defaultDbName;
+    this.db = this.client.db(targetDbName);
+    setDb(this.db);
+    console.info(`[core-db] Municipal MongoDB connected: ${targetDbName}`);
   }
 
   async disconnect(): Promise<void> {
     if (this.client) {
-      try {
-        await this.client.close();
-        this.client = null;
-        this.db = null;
-        console.info('Municipal Data MongoDB disconnected successfully');
-      } catch (error) {
-        console.error('Error disconnecting from Municipal Data MongoDB', error as Error);
-        throw error;
-      }
+      await this.client.close();
+      this.client = null;
+      this.db = null;
+      console.info("Municipal Data MongoDB disconnected successfully");
     }
   }
 
   getDb(): Db {
     if (!this.db) {
-      throw new Error('Municipal Data database not initialized. Call connect() first.');
+      throw new Error(
+        "Municipal Data database not initialized. Call connect() first.",
+      );
     }
     return this.db;
   }

package/src/municipal/streets/index.ts

@@ -1,2 +1,2 @@
-export * from './streets.getters';
-export type { Street, StreetDoc, StreetHint } from './streets.types';
+export * from "./streets.getters";
+export type { Street, StreetDoc, StreetHint } from "./streets.types";

package/src/municipal/streets/streets.getters.ts

@@ -1,25 +1,38 @@
-import {CityName, getDb, ObjectId, Street} from '../index';
-import type { StreetHint } from './streets.types';
-import { Collection, Filter, ObjectId as MongoObjectId } from 'mongodb';
+import { CityName, getDb, ObjectId, Street } from "../index";
+import type { StreetHint } from "./streets.types";
+import { Collection, Filter, ObjectId as MongoObjectId } from "mongodb";
 
 export const getStreetsCollection = (): Collection<Street> => {
-  return getDb().collection<Street>('streets');
+  return getDb().collection<Street>("streets");
 };
 
-export const findStreets = async (filter: Filter<Street> = {}): Promise<Street[]> => {
+export const findStreets = async (
+  filter: Filter<Street> = {},
+): Promise<Street[]> => {
   return await getStreetsCollection().find(filter).toArray();
 };
 
-export const getStreetById = async (streetId: string): Promise<Street | null> => {
-  const street = await getStreetsCollection().findOne({ _id: new ObjectId(streetId) });
+export const getStreetById = async (
+  streetId: string,
+): Promise<Street | null> => {
+  const street = await getStreetsCollection().findOne({
+    _id: new ObjectId(streetId),
+  });
   return street ? street : null;
 };
 
-export const getStreetsByCityName = async (cityName: CityName): Promise<Street[]> => {
-  return await getStreetsCollection().find({ cityName }).sort({ name: 1 }).toArray();
+export const getStreetsByCityName = async (
+  cityName: CityName,
+): Promise<Street[]> => {
+  return await getStreetsCollection()
+    .find({ cityName })
+    .sort({ name: 1 })
+    .toArray();
 };
 
-export const getStreetByStreetId = async (streetId: string): Promise<Street | null> => {
+export const getStreetByStreetId = async (
+  streetId: string,
+): Promise<Street | null> => {
   const street = await getStreetsCollection().findOne({ id: streetId });
   return street ? street : null;
 };
@@ -27,32 +40,37 @@ export const getStreetByStreetId = async (streetId: string): Promise<Street | nu
 /** Get street by business id and city. Use this when the client's city is known so the same id in another city is not returned. */
 export const getStreetByStreetIdAndCity = async (
   streetId: string,
-  cityName: CityName
+  cityName: CityName,
 ): Promise<Street | null> => {
-  const street = await getStreetsCollection().findOne({ id: streetId, cityName });
+  const street = await getStreetsCollection().findOne({
+    id: streetId,
+    cityName,
+  });
   return street ? street : null;
 };
 
 export const createStreet = async (
-  streetData: Omit<Street, '_id' | 'createdAt' | 'updatedAt'>
+  streetData: Omit<Street, "_id" | "createdAt" | "updatedAt">,
 ): Promise<MongoObjectId> => {
-  const street: Omit<Street, '_id'> = {
+  const street: Omit<Street, "_id"> = {
     ...streetData,
     createdAt: new Date(),
     updatedAt: new Date(),
   };
-  const { insertedId } = await getStreetsCollection().insertOne(street as Street);
+  const { insertedId } = await getStreetsCollection().insertOne(
+    street as Street,
+  );
   return insertedId;
 };
 
 export const updateStreet = async (
   streetId: string,
-  data: Partial<Omit<Street, '_id' | 'createdAt' | 'updatedAt'>>
+  data: Partial<Omit<Street, "_id" | "createdAt" | "updatedAt">>,
 ): Promise<Street | null> => {
   const result = await getStreetsCollection().findOneAndUpdate(
     { _id: new ObjectId(streetId) },
     { $set: { ...data, updatedAt: new Date() } },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
   return result || null;
 };
@@ -63,7 +81,7 @@ export const updateStreet = async (
  */
 export const upsertStreetHintOnStreet = async (
   street: Street,
-  hint: Partial<StreetHint> & Pick<StreetHint, 'text'>
+  hint: Partial<StreetHint> & Pick<StreetHint, "text">,
 ): Promise<Street | null> => {
   const text = hint.text.trim();
   if (!text) return null;
@@ -71,7 +89,7 @@ export const upsertStreetHintOnStreet = async (
   const hints = street.hints || [];
   let updatedHints: StreetHint[];
 
-  if (hint.id != null && hint.id !== '') {
+  if (hint.id != null && hint.id !== "") {
     const hintIndex = hints.findIndex((h) => String(h.id) === String(hint.id));
     if (hintIndex === -1) return null;
     updatedHints = [...hints];
@@ -86,20 +104,22 @@ export const upsertStreetHintOnStreet = async (
 /** Remove a hint from a street. streetId is the street business id (e.g. "703"). Updates document updatedAt. */
 export const deleteStreetHint = async (
   streetId: string,
-  hintId: string
+  hintId: string,
 ): Promise<Street | null> => {
   const result = await getStreetsCollection().findOneAndUpdate(
     { id: streetId },
     { $pull: { hints: { id: hintId } }, $set: { updatedAt: new Date() } },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
   if (result) {
-    console.info('Street hint deleted', { streetId, hintId });
+    console.info("Street hint deleted", { streetId, hintId });
   }
   return result || null;
 };
 
 export const deleteStreet = async (streetId: string): Promise<boolean> => {
-  const result = await getStreetsCollection().deleteOne({ _id: new ObjectId(streetId) });
+  const result = await getStreetsCollection().deleteOne({
+    _id: new ObjectId(streetId),
+  });
   return result.deletedCount > 0;
 };

package/src/municipal/streets/streets.types.ts

@@ -1,4 +1,4 @@
-import { ObjectId, WithId } from 'mongodb';
+import { ObjectId, WithId } from "mongodb";
 
 export type StreetHint = {
   id: string;