@talkpilot/core-db 1.0.13 → 1.0.15

package/dist/talkpilot/flows/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFlowsCollection = void 0;
+exports.findFlowById = exports.getFlowsCollection = void 0;
 var flows_getter_1 = require("./flows.getter");
 Object.defineProperty(exports, "getFlowsCollection", { enumerable: true, get: function () { return flows_getter_1.getFlowsCollection; } });
+Object.defineProperty(exports, "findFlowById", { enumerable: true, get: function () { return flows_getter_1.findFlowById; } });
 //# sourceMappingURL=index.js.map

package/dist/talkpilot/flows/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/talkpilot/flows/index.ts"],"names":[],"mappings":";;;AAAA,+CAAoD;AAA3C,kHAAA,kBAAkB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/talkpilot/flows/index.ts"],"names":[],"mappings":";;;AAAA,+CAAkE;AAAzD,kHAAA,kBAAkB,OAAA;AAAE,4GAAA,YAAY,OAAA"}

package/dist/test-utils/factories/municipal/departmentsSubjects.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"departmentsSubjects.d.ts","sourceRoot":"","sources":["../../../../src/test-utils/factories/municipal/departmentsSubjects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGlC,OAAO,KAAK,EACV,iBAAiB,EAElB,MAAM,kEAAkE,CAAC;AAI1E,eAAO,MAAM,wBAAwB,4GAclC,CAAC;AAEJ,wBAAgB,uBAAuB,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,iBAAiB,CAEjG"}
+{"version":3,"file":"departmentsSubjects.d.ts","sourceRoot":"","sources":["../../../../src/test-utils/factories/municipal/departmentsSubjects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGlC,OAAO,KAAK,EACV,iBAAiB,EAElB,MAAM,kEAAkE,CAAC;AAK1E,eAAO,MAAM,wBAAwB,4GAclC,CAAC;AAEJ,wBAAgB,uBAAuB,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,iBAAiB,CAEjG"}

package/dist/test-utils/factories/municipal/departmentsSubjects.js.map

@@ -1 +1 @@
-{"version":3,"file":"departmentsSubjects.js","sourceRoot":"","sources":["../../../../src/test-utils/factories/municipal/departmentsSubjects.ts"],"names":[],"mappings":";;;AA0BA,0DAEC;AA5BD,qCAAkC;AAClC,qCAAmC;AACnC,2CAAwC;AAMxC,MAAM,YAAY,GAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;AAEzE,QAAA,wBAAwB,GAAG,iBAAO,CAAC,MAAM,CAAoB,GAAG,EAAE,CAAC,CAAC;IAC/E,GAAG,EAAE,IAAI,kBAAQ,EAAE;IACnB,SAAS,EAAE,IAAI,IAAI,EAAE;IACrB,SAAS,EAAE,IAAI,IAAI,EAAE;IACrB,WAAW,EAAE,aAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACjC,UAAU,EAAE,aAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACnC,gBAAgB,EAAE,aAAK,CAAC,KAAK,CAAC,IAAI,EAAE;IACpC,cAAc,EAAE,aAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACvC,YAAY,EAAE,CAAC,aAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;IACtC,QAAQ,EAAE,aAAK,CAAC,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC;IAClD,UAAU,EAAE,IAAI;IAChB,YAAY,EAAE,EAAE;IAChB,cAAc,EAAE,EAAE;IAClB,GAAG,EAAE,aAAK,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;CAC7C,CAAC,CAAC,CAAC;AAEJ,SAAgB,uBAAuB,CAAC,SAAsC;IAC5E,OAAO,gCAAwB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;AACnD,CAAC"}
+{"version":3,"file":"departmentsSubjects.js","sourceRoot":"","sources":["../../../../src/test-utils/factories/municipal/departmentsSubjects.ts"],"names":[],"mappings":";;;AA2BA,0DAEC;AA7BD,qCAAkC;AAClC,qCAAmC;AACnC,2CAAwC;AAOxC,MAAM,YAAY,GAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;AAEzE,QAAA,wBAAwB,GAAG,iBAAO,CAAC,MAAM,CAAoB,GAAG,EAAE,CAAC,CAAC;IAC/E,GAAG,EAAE,IAAI,kBAAQ,EAAE;IACnB,SAAS,EAAE,IAAI,IAAI,EAAE;IACrB,SAAS,EAAE,IAAI,IAAI,EAAE;IACrB,WAAW,EAAE,aAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACjC,UAAU,EAAE,aAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACnC,gBAAgB,EAAE,aAAK,CAAC,KAAK,CAAC,IAAI,EAAE;IACpC,cAAc,EAAE,aAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACvC,YAAY,EAAE,CAAC,aAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;IACtC,QAAQ,EAAE,aAAK,CAAC,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC;IAClD,UAAU,EAAE,IAAI;IAChB,YAAY,EAAE,EAAE;IAChB,cAAc,EAAE,EAAE;IAClB,GAAG,EAAE,aAAK,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;CAC7C,CAAC,CAAC,CAAC;AAEJ,SAAgB,uBAAuB,CAAC,SAAsC;IAC5E,OAAO,gCAAwB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;AACnD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talkpilot/core-db",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Core database package for centralized connections and ORM integration.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -1,6 +1,6 @@
-import { getDb, DepartmentSubject } from '../index';
+import { getDb, DepartmentSubject, CityName } from '../index';
 import { Collection, Filter } from 'mongodb';
-import { CityName, VectorSearchResult } from './departmentsSubjects.types';
+import { VectorSearchResult } from './departmentsSubjects.types';
 
 export const getDepartmentsSubjectsCollection = (): Collection<DepartmentSubject> => {
   return getDb().collection<DepartmentSubject>('departmentsSubjects');

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

@@ -1,6 +1,7 @@
-import { ObjectId, WithId } from 'mongodb';
-import { Request } from 'express';
-import { ClientConfigDoc, Products } from '../../talkpilot/clientsConfig/clientsConfig.types';
+import {ObjectId, WithId} from 'mongodb';
+import {Request} from 'express';
+import {ClientConfigDoc, Products} from '../../talkpilot/clientsConfig/clientsConfig.types';
+import {CityName} from "../utils/types";
 
 export type DepartmentSubject = {
   _id: ObjectId;
@@ -56,11 +57,6 @@ export type VectorSearchResult = {
   score?: number;
 };
 
-/**
- * City name type for municipal data
- */
-// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-export type CityName = 'ashdod' | 'maltar' | 'billit' | 'hashkelon' | 'eilat' | 'tests' | string;
 export type CommunicationType = 'free_text_sms' | 'upload_url_sms';
 
 /**

package/src/municipal/departmentsSubjects/index.ts

@@ -3,7 +3,6 @@ export type {
   DepartmentSubject,
   DepartmentSubjectDoc,
   VectorSearchResult,
-  CityName,
   RequestWithClientConfig,
   Communication,
   Instruction,

package/src/municipal/index.ts

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

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

@@ -1,4 +1,4 @@
-import { CityName, getDb, ObjectId, Street } from '../index';
+import {CityName, getDb, ObjectId, Street} from '../index';
 import type { StreetHint } from './streets.types';
 import { Collection, Filter, ObjectId as MongoObjectId } from 'mongodb';
 

package/src/municipal/systemInstructions/__tests__/getters.spec.ts

@@ -0,0 +1,106 @@
+import { createSystemInstruction } from '../instructions.setters';
+import {
+  getSystemInstructionById,
+  getActiveSystemInstructionsByCity,
+  getAllActiveSystemInstructions,
+  getSystemInstructionsByToolAndCity,
+  findSystemInstructions
+} from '../instructions.getters';
+import { ObjectId } from 'mongodb';
+
+describe('System Instructions Getter Tests', () => {
+  const testCity = 'Ashdod';
+  const otherCity = 'Tel Aviv';
+
+  describe('getters', () => {
+    let instructionId: string;
+
+    beforeEach(async () => {
+      const id = await createSystemInstruction({
+        cityName: testCity,
+        instruction: 'Find Me',
+        isActive: true,
+        tool: "search tool",
+        queryType: "search tool",
+        tags: ['important', 'urgent']
+      });
+      instructionId = id.toString();
+      
+      // for filtering tests
+      await createSystemInstruction({
+        cityName: testCity,
+        instruction: 'Inactive One',
+        isActive: false,
+        tool: "search tool",
+        queryType: "search tool",
+      });
+
+      await createSystemInstruction({
+        cityName: otherCity,
+        instruction: 'Other City Instruction',
+        isActive: true,
+        tool: "other tool",
+        queryType: "other type",
+      });
+    });
+
+    describe('getSystemInstructionById', () => {
+        it('given existing id when fetched then return the document', async () => {
+            const result = await getSystemInstructionById(instructionId);
+            expect(result?._id.toString()).toBe(instructionId);
+        });
+
+        it('given non-existent id when fetched then return null', async () => {
+            const result = await getSystemInstructionById(new ObjectId().toHexString());
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('getActiveSystemInstructionsByCity', () => {
+        it('given city with active instructions when fetched then return only active documents for that city', async () => {
+            const result = await getActiveSystemInstructionsByCity(testCity);
+            expect(result.length).toBe(1);
+            expect(result[0].instruction).toBe('Find Me');
+        });
+
+        it('given city with no instructions when fetched then return empty array', async () => {
+            const result = await getActiveSystemInstructionsByCity('NonExistentCity');
+            expect(result).toEqual([]);
+        });
+    });
+
+    describe('getSystemInstructionsByToolAndCity', () => {
+        it('given valid city and tool when fetched then return matching instructions', async () => {
+            const result = await getSystemInstructionsByToolAndCity(testCity, 'search tool');
+            expect(result.length).toBe(2); // One active, one inactive
+            expect(result.every(r => r.cityName === testCity && r.tool === 'search tool')).toBe(true);
+        });
+
+        it('given valid city but wrong tool when fetched then return empty array', async () => {
+            const result = await getSystemInstructionsByToolAndCity(testCity, 'wrong tool');
+            expect(result).toEqual([]);
+        });
+    });
+
+    describe('findSystemInstructions', () => {
+        it('given filter by tags when searched then return matching documents', async () => {
+            const result = await findSystemInstructions({ tags: { $in: ['important'] } });
+            expect(result.length).toBe(1);
+            expect(result[0].instruction).toBe('Find Me');
+        });
+
+        it('given empty filter when searched then return all documents', async () => {
+            const result = await findSystemInstructions({});
+            expect(result.length).toBe(3);
+        });
+    });
+
+    describe('getAllActiveSystemInstructions', () => {
+        it('when fetched then return all active instructions from all cities', async () => {
+            const result = await getAllActiveSystemInstructions();
+            expect(result.length).toBe(2); // One from Ashdod, one from Tel Aviv
+            expect(result.every(r => r.isActive)).toBe(true);
+        });
+    });
+  });
+});

package/src/municipal/systemInstructions/__tests__/setters.spec.ts

@@ -0,0 +1,201 @@
+import {
+    createSystemInstruction,
+    updateSystemInstruction,
+    deleteSystemInstruction,
+    deactivateSystemInstruction,
+    activateSystemInstruction
+} from '../instructions.setters';
+import { getSystemInstructionById } from '../instructions.getters';
+import {SystemInstruction} from "../instructions.types";
+import { ObjectId } from 'mongodb';
+
+
+describe('System Instructions Setter Tests', () => {
+    const testCity = 'Ashdod';
+
+    describe('createSystemInstruction', () => {
+        it('given valid data when created then save document with timestamps', async () => {
+            // Given
+            const instructionData: Omit<SystemInstruction, '_id' | 'createdAt' | 'updatedAt'> = {
+                cityName: testCity,
+                instruction: 'Test Instruction',
+                isActive: true,
+                tool: "search tool",
+                queryType: "search tool",
+                tags: ['test', 'unit']
+            };
+
+            // When
+            const id = await createSystemInstruction(instructionData);
+
+            // Then
+            const saved = await getSystemInstructionById(id.toString());
+            expect(saved).toBeDefined();
+            expect(saved?._id).toBeDefined();
+            expect(saved).toMatchObject(instructionData);
+            expect(saved?.createdAt).toBeInstanceOf(Date);
+            expect(saved?.updatedAt).toBeInstanceOf(Date);
+        });
+
+        it('given data without tags when created then save document with default isActive true and no tags', async () => {
+            // Given
+            const instructionData: Omit<SystemInstruction, '_id' | 'createdAt' | 'updatedAt'> = {
+                cityName: testCity,
+                instruction: 'No Tags Instruction',
+                isActive: true,
+                tool: "minimal tool",
+                queryType: "minimal type",
+            };
+
+            // When
+            const id = await createSystemInstruction(instructionData);
+
+            // Then
+            const saved = await getSystemInstructionById(id.toString());
+            expect(saved).toBeDefined();
+            expect(saved?.tags).toBeUndefined();
+            expect(saved?.isActive).toBe(true);
+        });
+    });
+
+    describe('updateSystemInstruction', () => {
+        let instructionId: string;
+        //Given before each test
+        beforeEach(async () => {
+            const id = await createSystemInstruction({
+                cityName: testCity,
+                instruction: 'Find Me',
+                isActive: true,
+                tool: "search tool",
+                queryType: "search tool",
+            });
+            instructionId = id.toString();
+
+            await createSystemInstruction({
+                cityName: testCity,
+                instruction: 'Inactive One',
+                isActive: false,
+                tool: "search tool",
+                queryType: "search tool",
+            });
+        });
+        it('given existing doc when updated then change values and refresh updatedAt', async () => {
+
+            const originalDoc = await getSystemInstructionById(instructionId.toString());
+
+            // Wait a bit to ensure timestamp difference
+            await new Promise(resolve => setTimeout(resolve, 10));
+
+            // When
+            await updateSystemInstruction(instructionId.toString(), { instruction: 'New Text' });
+
+            // Then
+            const updatedDoc = await getSystemInstructionById(instructionId.toString());
+            expect(updatedDoc?.instruction).toBe('New Text');
+            expect(updatedDoc?.updatedAt.getTime()).toBeGreaterThan(originalDoc!.updatedAt.getTime());
+        });
+
+        it('given multiple fields when updated then change all provided values', async () => {
+            // When
+            await updateSystemInstruction(instructionId, {
+                isActive: false,
+                tool: 'updated tool',
+                tags: ['new-tag']
+            });
+
+            // Then
+            const updatedDoc = await getSystemInstructionById(instructionId);
+            expect(updatedDoc?.isActive).toBe(false);
+            expect(updatedDoc?.tool).toBe('updated tool');
+            expect(updatedDoc?.tags).toEqual(['new-tag']);
+        });
+
+        it('given system instructions, when deactivating it then its status updated to active', async () => {
+            //When
+            const success= await deactivateSystemInstruction(instructionId.toString());
+            const updatedDoc= await getSystemInstructionById(instructionId.toString());
+            //Then
+            expect(success).toBe(true);
+            expect(updatedDoc?.isActive).toBe(false);
+        })
+        it('given invalidId when deactivating it then return false', async () => {
+            //When
+            const success= await deactivateSystemInstruction(new ObjectId().toHexString());
+
+            //Then
+            expect(success).toBe(false);
+        })
+
+        it('given already inactive instruction when deactivating then still return true and remain inactive', async () => {
+            // Given
+            await deactivateSystemInstruction(instructionId);
+            
+            // When
+            const success = await deactivateSystemInstruction(instructionId);
+            
+            // Then
+            expect(success).toBe(true);
+            const doc = await getSystemInstructionById(instructionId);
+            expect(doc?.isActive).toBe(false);
+        });
+
+    });
+
+    describe('activateSystemInstruction', () => {
+        let instructionId: string;
+        beforeEach(async () => {
+            const id = await createSystemInstruction({
+                cityName: testCity,
+                instruction: 'Inactive Instruction',
+                isActive: false,
+                tool: "test",
+                queryType: "test",
+            });
+            instructionId = id.toString();
+        });
+
+        it('given inactive doc when activating then set isActive to true', async () => {
+            // When
+            const success = await activateSystemInstruction(instructionId);
+            
+            // Then
+            expect(success).toBe(true);
+            const updatedDoc = await getSystemInstructionById(instructionId);
+            expect(updatedDoc?.isActive).toBe(true);
+        });
+
+        it('given invalidId when activating then return false', async () => {
+            // When
+            const success = await activateSystemInstruction(new ObjectId().toHexString());
+
+            // Then
+            expect(success).toBe(false);
+        });
+    });
+
+    describe('deleteSystemInstruction', () => {
+        it('given existing id when deleted then remove document from DB', async () => {
+            const id = await createSystemInstruction({
+                cityName: testCity,
+                instruction: 'To be deleted',
+                isActive: true,
+                tool: "search tool",
+                queryType: "search tool",
+            });
+
+            const deleteResult = await deleteSystemInstruction(id.toString());
+            expect(deleteResult).toBe(true);
+
+            const findResult = await getSystemInstructionById(id.toString());
+            expect(findResult).toBeNull();
+        });
+
+        it('given non-existent id when deleting then return false', async () => {
+            // When
+            const result = await deleteSystemInstruction(new ObjectId().toHexString());
+            
+            // Then
+            expect(result).toBe(false);
+        });
+    });
+});

package/src/municipal/systemInstructions/index.ts

@@ -0,0 +1,3 @@
+export * from './instructions.getters';
+export * from './instructions.setters';
+export type { SystemInstruction } from './instructions.types';

package/src/municipal/systemInstructions/instructions.getters.ts

@@ -0,0 +1,45 @@
+import {CityName, getDb, ObjectId} from '../index';
+import { Collection, Filter } from 'mongodb';
+import { SystemInstruction } from './instructions.types';
+
+export const getSystemInstructionsCollection = (): Collection<SystemInstruction> => {
+  return getDb().collection<SystemInstruction>('system_instructions');
+};
+/**
+ * Find system instructions by filter
+ * @param filter filter to apply
+ * @returns array of system instructions
+ */
+export const findSystemInstructions = async (
+  filter: Filter<SystemInstruction> = {}
+): Promise<SystemInstruction[]> => {
+  return await getSystemInstructionsCollection().find(filter).toArray();
+};
+
+/**
+ * Get system instruction by id
+ * @param id system instruction id
+ * @returns system instruction or null if not found
+ */
+export const getSystemInstructionById = async (id: string): Promise<SystemInstruction | null> => {
+  return await getSystemInstructionsCollection().findOne({ _id: new ObjectId(id) });
+}
+/**
+ * Get all active system instructions for a city
+ * @param cityName city name
+ * @returns array of active system instructions
+ */
+export const getActiveSystemInstructionsByCity = async (cityName: CityName): Promise<SystemInstruction[]> => {
+  return await getSystemInstructionsCollection().find({cityName, isActive: true}).toArray();
+}
+/**
+ * Get system instructions by tool and city
+ * @param cityName city name
+ * @param toolName tool name
+ * @returns array of system instructions
+ */
+export const getSystemInstructionsByToolAndCity = async (cityName: CityName, toolName: string): Promise<SystemInstruction[]> => {
+  return await getSystemInstructionsCollection().find({cityName: cityName, tool: toolName}).toArray();
+}
+
+

package/src/municipal/systemInstructions/instructions.setters.ts

@@ -0,0 +1,79 @@
+import { ObjectId } from '../index';
+import { ObjectId as MongoObjectId } from 'mongodb';
+import { SystemInstruction } from './instructions.types';
+import { getSystemInstructionsCollection } from './instructions.getters';
+
+/**
+ * Create a new system instruction
+ * @param instructionData system instruction data
+ * @returns inserted system instruction id
+ */
+export const createSystemInstruction = async (
+  instructionData: Omit<SystemInstruction, '_id' | 'createdAt' | 'updatedAt'>
+): Promise<MongoObjectId> => {
+  const instruction: Omit<SystemInstruction, '_id'> = { //append doc metadata to user provided data
+    ...instructionData,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+  const { insertedId } = await getSystemInstructionsCollection().insertOne(
+    instruction as SystemInstruction
+  );
+  return insertedId;
+};
+
+/**
+ * Update a system instruction by id
+ * @param id system instruction id
+ * @param data partial system instruction data
+ * @returns updated system instruction or null if not found
+ */
+export const updateSystemInstruction = async (
+  id: string,
+  data: Partial<Omit<SystemInstruction, '_id' | 'createdAt' | 'updatedAt'>>
+): Promise<SystemInstruction | null> => {
+  const result = await getSystemInstructionsCollection().findOneAndUpdate(
+    { _id: new ObjectId(id) },
+    { $set: { ...data, updatedAt: new Date() } },
+    { returnDocument: 'after' }
+  );
+  return result || null;
+};
+
+/**
+ * Delete a system instruction by id
+ * @param id system instruction id
+ * @returns true if deleted, false otherwise
+ */
+export const deleteSystemInstruction = async (id: string): Promise<boolean> => {
+  const result = await getSystemInstructionsCollection().deleteOne({ _id: new ObjectId(id) });
+  return result.deletedCount > 0;
+};
+/**
+ * Activate a system instruction by id, sets isActive to true.
+ * Does not check the current instruction state, calling this on an active instruction will do nothing.
+ * @param id system instruction id
+ * @returns true on success, false otherwise
+ */
+export const activateSystemInstruction = async (id: string): Promise<boolean> => {
+  const result = await getSystemInstructionsCollection().findOneAndUpdate(
+    { _id: new ObjectId(id) },
+    { $set: { isActive: true } },
+    { returnDocument: 'after' }
+  );
+  return Boolean(result);
+};
+/**
+ * Deactivate a system instruction by id, sets isActive to false.
+ * Does not check the current instruction state, calling this on a deactivated instruction will do nothing.
+ * @param id system instruction id
+ * @returns true on success, false otherwise
+ */
+export const deactivateSystemInstruction = async (id: string): Promise<boolean> => {
+  const result = await getSystemInstructionsCollection().findOneAndUpdate(
+    { _id: new ObjectId(id) },
+    { $set: { isActive: false } },
+      {returnDocument: 'after'}
+  );
+  return Boolean(result);
+}

package/src/municipal/systemInstructions/instructions.types.ts

@@ -0,0 +1,15 @@
+import { ObjectId } from 'mongodb';
+
+import {CityName} from "../utils/types";
+
+export type SystemInstruction = {
+  _id: ObjectId;
+  createdAt: Date;
+  updatedAt: Date;
+  cityName: CityName;
+  instruction: string;
+  isActive: boolean;
+  tool: string;
+  queryType: string;
+  tags?: string[]; //no tags implies all wildcard (?)
+};

package/src/municipal/tickets/tickets.getters.ts

@@ -1,4 +1,4 @@
-import { CityName, getDb, ObjectId, Ticket } from '../index';
+import {CityName, getDb, ObjectId, Ticket} from '../index';
 import type { SubjectStatsItem } from './tickets.types';
 import { Collection, Filter, ObjectId as MongoObjectId } from 'mongodb';
 

package/src/municipal/tickets/tickets.types.ts

@@ -1,5 +1,6 @@
 import { ObjectId, WithId } from 'mongodb';
-import { CityName } from '../departmentsSubjects/departmentsSubjects.types';
+
+import {CityName} from "../utils/types";
 
 export type Ticket = {
   _id: ObjectId;

package/src/municipal/utils/types.ts

@@ -0,0 +1,6 @@
+
+
+/**
+ * City name type for municipal data
+ */
+export type CityName = 'ashdod' | 'maltar' | 'billit' | 'hashkelon' | 'eilat' | 'tests' | string;

package/src/talkpilot/flows/__tests__/flows.schema.spec.ts

@@ -0,0 +1,13 @@
+import { flowMongoSchema } from '../flows.schema';
+
+describe('flowMongoSchema', () => {
+  it('defines silenceTimeoutSeconds as optional number or null', () => {
+    const schema: any = flowMongoSchema;
+
+    expect(schema.properties).toHaveProperty('silenceTimeoutSeconds');
+    expect(schema.properties.silenceTimeoutSeconds.bsonType).toEqual(['number', 'null']);
+    expect(schema.required).not.toContain('silenceTimeoutSeconds');
+    expect(schema.additionalProperties).toBe(false);
+  });
+});
+

package/src/talkpilot/flows/flows.schema.ts

@@ -8,6 +8,7 @@ export const flowMongoSchema = {
     systemInstructions: { bsonType: 'string' },
     initialSentence: { bsonType: 'string' },
     voice: { bsonType: ['string', 'null'] },
+    silenceTimeoutSeconds: { bsonType: ['number', 'null'] },
     interactions: {
       bsonType: 'array',
       items: {

package/src/talkpilot/flows/flows.types.ts

@@ -139,6 +139,7 @@ export type Flow = {
   voice?: string;
 
   insights: string[];
+  silenceTimeoutSeconds?: number;
 
   interactions: Interaction[];
 

package/src/talkpilot/flows/index.ts

@@ -1,2 +1,2 @@
-export { getFlowsCollection } from './flows.getter';
+export { getFlowsCollection, findFlowById } from './flows.getter';
 export type * from './flows.types';

package/src/talkpilot/phone_numbers/__tests__/phone_numbers.spec.ts

@@ -12,7 +12,7 @@ import { ObjectId } from 'mongodb';
 describe('db.phoneNumbers', () => {
   describe('getPhoneDataByPhoneNumber', () => {
     it('return phone number data with flow', async () => {
-      const flow = createFlow({ clientId: 'test-client-id' });
+      const flow = createFlow({ clientId: 'test-client-id', silenceTimeoutSeconds: 60 });
       const phoneData = createPhoneNumber({ flow_id: flow._id, client_id: 'test-client-id' });
       
       await getFlowsCollection().insertOne(flow);
@@ -28,6 +28,7 @@ describe('db.phoneNumbers', () => {
       });
       // Specifically check if the flow was joined correctly
       expect(result?.flow.flowName).toBe(flow.flowName);
+      expect(result?.flow.silenceTimeoutSeconds).toBe(60);
     });
   });
 

package/src/talkpilot/sessions/__tests__/sessions.spec.ts

@@ -10,7 +10,7 @@ describe('sessions', () => {
     it('returns session by incoming phone number', async () => {
       const to = '+972500000000';
       const from = '+972540000000';
-      const flow = createFlow();
+      const flow = createFlow({ silenceTimeoutSeconds: 60 });
       const phoneNumberData = createPhoneNumber({ phone_number: to, flow_id: flow._id });
       const json = { [faker.lorem.word()]: faker.lorem.sentence() };
 

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

@@ -3,8 +3,9 @@ import { ObjectId } from 'mongodb';
 import { faker } from '@faker-js/faker';
 import type {
   DepartmentSubject,
-  CityName,
+
 } from '../../../municipal/departmentsSubjects/departmentsSubjects.types';
+import {CityName} from "../../../municipal";
 
 const VALID_CITIES: CityName[] = ['ashdod', 'maltar', 'billit', 'hashkelon', 'tests'];