@talkpilot/core-db 1.3.28 → 1.3.30

package/src/municipal/departmentsSubjects/__tests__/departmentsSubjects.spec.ts

@@ -1,272 +0,0 @@
-import { ObjectId } from 'mongodb';
-import {
-  getDepartmentsSubjectsCollection,
-  getAllDepartmentsSubjectsByCity,
-  bulkWriteDepartmentsSubjects,
-  findDepartmentSubjectsByFilter,
-  updateDepartmentSubjectActive,
-} from '../departmentsSubjects.getters';
-import { createDepartmentSubject } from '../../../test-utils/factories/municipal/departmentsSubjects';
-
-const CITY = 'tests' as const;
-
-describe('DepartmentSubject — isActive field', () => {
-  describe('persistence', () => {
-    it('a document inserted without isActive is retrievable and the field is absent', async () => {
-      const subject = createDepartmentSubject({ cityName: CITY });
-      delete (subject as Partial<typeof subject>).isActive;
-
-      await getDepartmentsSubjectsCollection().insertOne(subject);
-
-      const saved = await getDepartmentsSubjectsCollection().findOne({ _id: subject._id });
-      expect(saved).not.toBeNull();
-      expect(saved).not.toHaveProperty('isActive');
-    });
-
-    it('isActive: true is persisted and returned', async () => {
-      const subject = createDepartmentSubject({ cityName: CITY, isActive: true });
-      await getDepartmentsSubjectsCollection().insertOne(subject);
-
-      const saved = await getDepartmentsSubjectsCollection().findOne({ _id: subject._id });
-      expect(saved?.isActive).toBe(true);
-    });
-
-    it('isActive: false is persisted and returned', async () => {
-      const subject = createDepartmentSubject({ cityName: CITY, isActive: false });
-      await getDepartmentsSubjectsCollection().insertOne(subject);
-
-      const saved = await getDepartmentsSubjectsCollection().findOne({ _id: subject._id });
-      expect(saved?.isActive).toBe(false);
-    });
-  });
-
-  describe('querying', () => {
-    it('getAllDepartmentsSubjectsByCity returns all subjects regardless of isActive', async () => {
-      const activeSubject = createDepartmentSubject({ cityName: CITY, isActive: true });
-      const inactiveSubject = createDepartmentSubject({ cityName: CITY, isActive: false });
-      const noFlagSubject = createDepartmentSubject({ cityName: CITY });
-      delete (noFlagSubject as Partial<typeof noFlagSubject>).isActive;
-
-      await getDepartmentsSubjectsCollection().insertMany([activeSubject, inactiveSubject, noFlagSubject]);
-
-      const all = await getAllDepartmentsSubjectsByCity(CITY);
-      expect(all).toHaveLength(3);
-
-      const active = all.find((s) => s._id.equals(activeSubject._id));
-      const inactive = all.find((s) => s._id.equals(inactiveSubject._id));
-      const noFlag = all.find((s) => s._id.equals(noFlagSubject._id));
-
-      expect(active?.isActive).toBe(true);
-      expect(inactive?.isActive).toBe(false);
-      expect(noFlag?.isActive).toBeUndefined(); // absent in DB → getter is a pass-through, no normalization
-    });
-
-    it('filtering with isActive !== false excludes inactive and includes active and unset documents', async () => {
-      const activeSubject = createDepartmentSubject({ cityName: CITY, isActive: true });
-      const inactiveSubject = createDepartmentSubject({ cityName: CITY, isActive: false });
-      const noFlagSubject = createDepartmentSubject({ cityName: CITY });
-      delete (noFlagSubject as Partial<typeof noFlagSubject>).isActive;
-
-      await getDepartmentsSubjectsCollection().insertMany([activeSubject, inactiveSubject, noFlagSubject]);
-
-      // This is the exact filter pattern used by the sync script to skip already-inactive records
-      const notInactive = await getDepartmentsSubjectsCollection()
-        .find({ cityName: CITY, isActive: { $ne: false } })
-        .toArray();
-
-      expect(notInactive).toHaveLength(2);
-      expect(notInactive.map((s) => s._id.toString())).toEqual(
-        expect.arrayContaining([activeSubject._id.toString(), noFlagSubject._id.toString()])
-      );
-      expect(notInactive.map((s) => s._id.toString())).not.toContain(inactiveSubject._id.toString());
-    });
-  });
-
-  describe('updating', () => {
-    it('isActive can be set to false on an existing active document (deactivation)', async () => {
-      const subject = createDepartmentSubject({ cityName: CITY, isActive: true });
-      await getDepartmentsSubjectsCollection().insertOne(subject);
-
-      await getDepartmentsSubjectsCollection().updateOne(
-        { _id: subject._id },
-        { $set: { isActive: false, updatedAt: new Date() } }
-      );
-
-      const updated = await getDepartmentsSubjectsCollection().findOne({ _id: subject._id });
-      expect(updated?.isActive).toBe(false);
-    });
-
-    it('isActive can be set to true on a deactivated document (reactivation)', async () => {
-      const subject = createDepartmentSubject({ cityName: CITY, isActive: false });
-      await getDepartmentsSubjectsCollection().insertOne(subject);
-
-      await getDepartmentsSubjectsCollection().updateOne(
-        { _id: subject._id },
-        { $set: { isActive: true, updatedAt: new Date() } }
-      );
-
-      const updated = await getDepartmentsSubjectsCollection().findOne({ _id: subject._id });
-      expect(updated?.isActive).toBe(true);
-    });
-
-    it('deactivating a subject does not touch other fields', async () => {
-      const subject = createDepartmentSubject({
-        cityName: CITY,
-        isActive: true,
-        guidelines: 'handle with care',
-        instructions: [{ id: 1, instruction: 'call back within 2h' }],
-        sla: 48,
-      });
-      await getDepartmentsSubjectsCollection().insertOne(subject);
-
-      await getDepartmentsSubjectsCollection().updateOne(
-        { _id: subject._id },
-        { $set: { isActive: false, updatedAt: new Date() } }
-      );
-
-      const updated = await getDepartmentsSubjectsCollection().findOne({ _id: subject._id });
-      expect(updated?.isActive).toBe(false);
-      expect(updated?.guidelines).toBe('handle with care');
-      expect(updated?.instructions).toEqual([{ id: 1, instruction: 'call back within 2h' }]);
-      expect(updated?.sla).toBe(48);
-    });
-  });
-
-  describe('bulkWriteDepartmentsSubjects', () => {
-    it('applies upsert and update operations from a single batch', async () => {
-      const existing = createDepartmentSubject({ cityName: CITY, subjectName: 'Old Name' });
-      await getDepartmentsSubjectsCollection().insertOne(existing);
-
-      const result = await bulkWriteDepartmentsSubjects(
-        [
-          {
-            updateOne: {
-              filter: { _id: existing._id },
-              update: { $set: { subjectName: 'New Name' } },
-            },
-          },
-          {
-            updateOne: {
-              filter: { cityName: CITY, subject_id: 'brand-new', sub_subject_id: 'sub-1' },
-              update: {
-                $set: { subjectName: 'Brand New Subject', sub_subject_name: 'Sub One' },
-                $setOnInsert: {
-                  subject_id: 'brand-new',
-                  sub_subject_id: 'sub-1',
-                  cityName: CITY,
-                  instructions: [],
-                  descriptions: [],
-                  createdAt: new Date(),
-                  isActive: true,
-                },
-              },
-              upsert: true,
-            },
-          },
-        ],
-        { ordered: false }
-      );
-
-      expect(result.modifiedCount).toBe(1);
-      expect(result.upsertedCount).toBe(1);
-
-      const updated = await getDepartmentsSubjectsCollection().findOne({ _id: existing._id });
-      expect(updated?.subjectName).toBe('New Name');
-
-      const inserted = await getDepartmentsSubjectsCollection().findOne({
-        subject_id: 'brand-new',
-        sub_subject_id: 'sub-1',
-      });
-      expect(inserted?.subjectName).toBe('Brand New Subject');
-    });
-
-    it('propagates a MongoBulkWriteError for an invalid operation, preserving partial results', async () => {
-      const existing = createDepartmentSubject({ cityName: CITY });
-      await getDepartmentsSubjectsCollection().insertOne(existing);
-
-      await expect(
-        bulkWriteDepartmentsSubjects(
-          [
-            {
-              updateOne: {
-                filter: { _id: existing._id },
-                update: { $set: { subjectName: 'Valid Update' } },
-              },
-            },
-            {
-              insertOne: {
-                // Duplicate _id triggers a write error without aborting the ordered:false batch
-                document: { ...existing },
-              },
-            },
-          ],
-          { ordered: false }
-        )
-      ).rejects.toMatchObject({ name: 'MongoBulkWriteError' });
-
-      const updated = await getDepartmentsSubjectsCollection().findOne({ _id: existing._id });
-      expect(updated?.subjectName).toBe('Valid Update');
-    });
-  });
-
-  describe('findDepartmentSubjectsByFilter', () => {
-    it('returns all documents matching the given filter', async () => {
-      const match1 = createDepartmentSubject({ cityName: CITY, subject_id: 'r1', sub_subject_id: 's1' });
-      const match2 = createDepartmentSubject({ cityName: CITY, subject_id: 'r1', sub_subject_id: 's2' });
-      const nonMatch = createDepartmentSubject({ cityName: CITY, subject_id: 'r2', sub_subject_id: 's3' });
-      await getDepartmentsSubjectsCollection().insertMany([match1, match2, nonMatch]);
-
-      const docs = await findDepartmentSubjectsByFilter({ cityName: CITY, subject_id: 'r1' });
-
-      expect(docs.map((doc) => doc._id.toString())).toEqual(
-        expect.arrayContaining([match1._id.toString(), match2._id.toString()])
-      );
-      expect(docs).toHaveLength(2);
-    });
-
-    it('returns an empty array when nothing matches', async () => {
-      const docs = await findDepartmentSubjectsByFilter({
-        cityName: CITY,
-        subject_id: 'does-not-exist',
-      });
-      expect(docs).toEqual([]);
-    });
-  });
-
-  describe('updateDepartmentSubjectActive', () => {
-    it('sets isActive on the document with the given _id and returns it', async () => {
-      const subject = createDepartmentSubject({ cityName: CITY, isActive: true });
-      await getDepartmentsSubjectsCollection().insertOne(subject);
-
-      const updated = await updateDepartmentSubjectActive(subject._id, false);
-
-      expect(updated?.isActive).toBe(false);
-      const saved = await getDepartmentsSubjectsCollection().findOne({ _id: subject._id });
-      expect(saved?.isActive).toBe(false);
-    });
-
-    it('returns null when no document matches the given _id', async () => {
-      const updated = await updateDepartmentSubjectActive(new ObjectId(), true);
-      expect(updated).toBeNull();
-    });
-
-    it('does not touch other fields when updating isActive', async () => {
-      const subject = createDepartmentSubject({
-        cityName: CITY,
-        isActive: true,
-        guidelines: 'handle with care',
-        instructions: [{ id: 1, instruction: 'call back within 2h' }],
-        sla: 48,
-      });
-      await getDepartmentsSubjectsCollection().insertOne(subject);
-
-      await updateDepartmentSubjectActive(subject._id, false);
-
-      const updated = await getDepartmentsSubjectsCollection().findOne({ _id: subject._id });
-      expect(updated?.isActive).toBe(false);
-      expect(updated?.guidelines).toBe('handle with care');
-      expect(updated?.instructions).toEqual([{ id: 1, instruction: 'call back within 2h' }]);
-      expect(updated?.sla).toBe(48);
-    });
-  });
-});

package/src/municipal/streets/__tests__/streets.spec.ts

@@ -1,253 +0,0 @@
-import {
-  getStreetsCollection,
-  getStreetsByCityName,
-  getStreetById,
-  getStreetByStreetId,
-  getStreetByStreetIdAndCity,
-  createStreet,
-  bulkWriteStreets,
-} from '../streets.getters';
-import { createStreet as streetFactory } from '../../../test-utils/factories/municipal/streets';
-
-const CITY = 'tests' as const;
-
-describe('Street — isActive field', () => {
-  describe('persistence', () => {
-    it('a document inserted without isActive is retrievable and the field is absent', async () => {
-      const street = streetFactory({ cityName: CITY });
-      delete (street as Partial<typeof street>).isActive;
-
-      await getStreetsCollection().insertOne(street);
-
-      const saved = await getStreetsCollection().findOne({ _id: street._id });
-      expect(saved).not.toBeNull();
-      expect(saved).not.toHaveProperty('isActive');
-    });
-
-    it('isActive: true is persisted and returned', async () => {
-      const street = streetFactory({ cityName: CITY, isActive: true });
-      await getStreetsCollection().insertOne(street);
-
-      const saved = await getStreetsCollection().findOne({ _id: street._id });
-      expect(saved?.isActive).toBe(true);
-    });
-
-    it('isActive: false is persisted and returned', async () => {
-      const street = streetFactory({ cityName: CITY, isActive: false });
-      await getStreetsCollection().insertOne(street);
-
-      const saved = await getStreetsCollection().findOne({ _id: street._id });
-      expect(saved?.isActive).toBe(false);
-    });
-  });
-
-  describe('createStreet', () => {
-    it('defaults isActive to true when not provided', async () => {
-      const data = streetFactory({ cityName: CITY });
-      delete (data as Partial<typeof data>).isActive;
-
-      const insertedId = await createStreet(data);
-
-      const saved = await getStreetsCollection().findOne({ _id: insertedId });
-      expect(saved?.isActive).toBe(true);
-    });
-
-    it('persists isActive: false when explicitly passed', async () => {
-      const data = streetFactory({ cityName: CITY, isActive: false });
-      const insertedId = await createStreet(data);
-
-      const saved = await getStreetsCollection().findOne({ _id: insertedId });
-      expect(saved?.isActive).toBe(false);
-    });
-  });
-
-  describe('querying', () => {
-    it('getStreetsByCityName returns all streets regardless of isActive', async () => {
-      const active = streetFactory({ cityName: CITY, isActive: true });
-      const inactive = streetFactory({ cityName: CITY, isActive: false });
-      const noFlag = streetFactory({ cityName: CITY });
-      delete (noFlag as Partial<typeof noFlag>).isActive;
-
-      await getStreetsCollection().insertMany([active, inactive, noFlag]);
-
-      const all = await getStreetsByCityName(CITY);
-      expect(all.length).toBeGreaterThanOrEqual(3);
-
-      const returnedActive = all.find((s) => s._id.equals(active._id));
-      const returnedInactive = all.find((s) => s._id.equals(inactive._id));
-      const returnedNoFlag = all.find((s) => s._id.equals(noFlag._id));
-
-      expect(returnedActive?.isActive).toBe(true);
-      expect(returnedInactive?.isActive).toBe(false);
-      expect(returnedNoFlag?.isActive).toBeUndefined(); // absent in DB → getter is a pass-through, no normalization
-    });
-
-    it('getStreetById returns isActive undefined when absent in DB', async () => {
-      const street = streetFactory({ cityName: CITY });
-      delete (street as Partial<typeof street>).isActive;
-      await getStreetsCollection().insertOne(street);
-
-      const result = await getStreetById(street._id.toString());
-      expect(result?.isActive).toBeUndefined();
-    });
-
-    it('getStreetById returns isActive: false unchanged', async () => {
-      const street = streetFactory({ cityName: CITY, isActive: false });
-      await getStreetsCollection().insertOne(street);
-
-      const result = await getStreetById(street._id.toString());
-      expect(result?.isActive).toBe(false);
-    });
-
-    it('getStreetByStreetId returns isActive undefined when absent in DB', async () => {
-      const street = streetFactory({ cityName: CITY });
-      delete (street as Partial<typeof street>).isActive;
-      await getStreetsCollection().insertOne(street);
-
-      const result = await getStreetByStreetId(street.id);
-      expect(result?.isActive).toBeUndefined();
-    });
-
-    it('getStreetByStreetIdAndCity returns isActive undefined when absent in DB', async () => {
-      const street = streetFactory({ cityName: CITY });
-      delete (street as Partial<typeof street>).isActive;
-      await getStreetsCollection().insertOne(street);
-
-      const result = await getStreetByStreetIdAndCity(street.id, CITY);
-      expect(result?.isActive).toBeUndefined();
-    });
-
-    it('filtering with isActive !== false excludes inactive and includes active and unset documents', async () => {
-      const active = streetFactory({ cityName: CITY, isActive: true });
-      const inactive = streetFactory({ cityName: CITY, isActive: false });
-      const noFlag = streetFactory({ cityName: CITY });
-      delete (noFlag as Partial<typeof noFlag>).isActive;
-
-      await getStreetsCollection().insertMany([active, inactive, noFlag]);
-
-      // This is the exact filter pattern used by the sync script to skip already-inactive records
-      const notInactive = await getStreetsCollection()
-        .find({ cityName: CITY, isActive: { $ne: false } })
-        .toArray();
-
-      expect(notInactive.map((s) => s._id.toString())).toEqual(
-        expect.arrayContaining([active._id.toString(), noFlag._id.toString()])
-      );
-      expect(notInactive.map((s) => s._id.toString())).not.toContain(inactive._id.toString());
-    });
-  });
-
-  describe('updating', () => {
-    it('isActive can be set to false on an existing active document (deactivation)', async () => {
-      const street = streetFactory({ cityName: CITY, isActive: true });
-      await getStreetsCollection().insertOne(street);
-
-      await getStreetsCollection().updateOne(
-        { _id: street._id },
-        { $set: { isActive: false, updatedAt: new Date() } }
-      );
-
-      const updated = await getStreetsCollection().findOne({ _id: street._id });
-      expect(updated?.isActive).toBe(false);
-    });
-
-    it('isActive can be set to true on a deactivated document (reactivation)', async () => {
-      const street = streetFactory({ cityName: CITY, isActive: false });
-      await getStreetsCollection().insertOne(street);
-
-      await getStreetsCollection().updateOne(
-        { _id: street._id },
-        { $set: { isActive: true, updatedAt: new Date() } }
-      );
-
-      const updated = await getStreetsCollection().findOne({ _id: street._id });
-      expect(updated?.isActive).toBe(true);
-    });
-
-    it('deactivating a street does not touch other fields', async () => {
-      const street = streetFactory({
-        cityName: CITY,
-        isActive: true,
-        name: 'Herzl St',
-        hints: [{ id: '1', text: 'near the park' }],
-      });
-      await getStreetsCollection().insertOne(street);
-
-      await getStreetsCollection().updateOne(
-        { _id: street._id },
-        { $set: { isActive: false, updatedAt: new Date() } }
-      );
-
-      const updated = await getStreetsCollection().findOne({ _id: street._id });
-      expect(updated?.isActive).toBe(false);
-      expect(updated?.name).toBe('Herzl St');
-      expect(updated?.hints).toEqual([{ id: '1', text: 'near the park' }]);
-    });
-  });
-
-  describe('bulkWriteStreets', () => {
-    it('applies upsert and update operations from a single batch', async () => {
-      const existing = streetFactory({ cityName: CITY, name: 'Old Name' });
-      await getStreetsCollection().insertOne(existing);
-
-      const result = await bulkWriteStreets(
-        [
-          {
-            updateOne: {
-              filter: { _id: existing._id },
-              update: { $set: { name: 'New Name' } },
-            },
-          },
-          {
-            updateOne: {
-              filter: { id: 'brand-new-street', cityName: CITY },
-              update: {
-                $set: { name: 'Brand New St', cityName: CITY },
-                $setOnInsert: { id: 'brand-new-street', createdAt: new Date(), isActive: true },
-              },
-              upsert: true,
-            },
-          },
-        ],
-        { ordered: false }
-      );
-
-      expect(result.modifiedCount).toBe(1);
-      expect(result.upsertedCount).toBe(1);
-
-      const updated = await getStreetsCollection().findOne({ _id: existing._id });
-      expect(updated?.name).toBe('New Name');
-
-      const inserted = await getStreetsCollection().findOne({ id: 'brand-new-street', cityName: CITY });
-      expect(inserted?.name).toBe('Brand New St');
-    });
-
-    it('propagates a MongoBulkWriteError for an invalid operation, preserving partial results', async () => {
-      const existing = streetFactory({ cityName: CITY });
-      await getStreetsCollection().insertOne(existing);
-
-      await expect(
-        bulkWriteStreets(
-          [
-            {
-              updateOne: {
-                filter: { _id: existing._id },
-                update: { $set: { name: 'Valid Update' } },
-              },
-            },
-            {
-              insertOne: {
-                // Duplicate _id triggers a write error without aborting the ordered:false batch
-                document: { ...existing },
-              },
-            },
-          ],
-          { ordered: false }
-        )
-      ).rejects.toMatchObject({ name: 'MongoBulkWriteError' });
-
-      const updated = await getStreetsCollection().findOne({ _id: existing._id });
-      expect(updated?.name).toBe('Valid Update');
-    });
-  });
-});