@tiledesk/tiledesk-server 2.18.1 → 2.18.3

package/CHANGELOG.md

@@ -5,9 +5,13 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
-# 2.18.1
+# 2.18.3
 - Added permissions logic
 - Added custom roles support
+- Add answered questions functionality
+- Added AnsweredQuestion schema with TTL index for automatic deletion.
+- Updated UnansweredQuestion schema to include additional fields and improved query handling for searching and sorting.
+- Enhanced the deletion process for unanswered questions.
 
 # 2.17.4
 - Refactor error handling and code structure in webhook.js

package/app.js

@@ -130,6 +130,7 @@ var integration = require('./routes/integration')
 var kbsettings = require('./routes/kbsettings');
 var kb = require('./routes/kb');
 var unanswered = require('./routes/unanswered');
+var answered = require('./routes/answered');
 
 // var admin = require('./routes/admin');
 var faqpub = require('./routes/faqpub');
@@ -643,6 +644,7 @@ app.use('/:projectid/mcp', [passport.authenticate(['basic', 'jwt'], { session: f
 
 app.use('/:projectid/kbsettings', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('agent', ['bot','subscription'])], kbsettings);
 app.use('/:projectid/kb/unanswered', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('admin', ['bot','subscription'])], unanswered);
+app.use('/:projectid/kb/answered', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('admin', ['bot','subscription'])], answered);
 app.use('/:projectid/kb', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('admin', ['bot','subscription'])], kb);
 
 app.use('/:projectid/logs', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('agent')], logs);

package/docs/routes-answered.md

@@ -0,0 +1,153 @@
+# Route `kb/answered` — domande con risposta (Knowledge Base)
+
+Documentazione per [`routes/answered.js`](../routes/answered.js).
+
+## Scopo
+
+API REST per gestire le **domande già risposte** associate a un **namespace** della Knowledge Base del progetto. I documenti sono persistiti nel modello Mongoose `AnsweredQuestion` (vedi [`models/kb_setting.js`](../models/kb_setting.js)).
+
+Ogni operazione è vincolata al **progetto corrente** (`req.projectid`, derivato dal segmento `:projectid` nell’URL) e alla validità del **namespace** (deve esistere un `Namespace` con `id` uguale al `namespace` richiesto e `id_project` uguale al progetto).
+
+## Montaggio e autenticazione
+
+In [`app.js`](../app.js) il router è montato così:
+
+- **Path base:** `/:projectid/kb/answered`
+- **Middleware:** `passport.authenticate(['basic', 'jwt'])`, `validtoken`, `roleChecker.hasRoleOrTypes('admin', ['bot','subscription'])`
+
+Sono quindi richiesti autenticazione (Basic o JWT), token valido e ruolo **admin** oppure tipi **bot** / **subscription**.
+
+Esempio di URL completo (sviluppo locale):
+
+```http
+GET http://localhost:3000/{projectId}/kb/answered/{namespace}
+```
+
+Sostituire `{projectId}` con l’ID MongoDB del progetto.
+
+## Modello dati (`AnsweredQuestion`)
+
+| Campo         | Tipo     | Note                                      |
+|---------------|----------|-------------------------------------------|
+| `id_project`  | string   | Impostato dal server dal contesto progetto |
+| `namespace`   | string   | ID del namespace (validato contro `Namespace`) |
+| `question`    | string   | Obbligatorio                              |
+| `answer`      | string   | Obbligatorio                              |
+| `tokens`      | number   | Opzionale                                 |
+| `request_id`  | string   | Opzionale                                 |
+| `created_at` / `updated_at` | date | Da `timestamps: true`              |
+
+Indici rilevanti: TTL su `created_at`, indice composto `(id_project, namespace, created_at)`, indice **testo** su `question` e `answer` (pesi question 5, answer 1) per la ricerca full-text.
+
+---
+
+## Endpoint
+
+Tutti i path qui sotto sono relativi a `/:projectid/kb/answered`.
+
+### `POST /`
+
+Aggiunge una nuova domanda risposta.
+
+**Body JSON**
+
+| Campo        | Obbligatorio | Descrizione        |
+|-------------|--------------|--------------------|
+| `namespace` | sì           | ID namespace       |
+| `question`  | sì           | Testo domanda      |
+| `answer`    | sì           | Testo risposta     |
+| `tokens`    | no           | Numero opzionale   |
+| `request_id`| no           | Riferimento richiesta |
+
+**Risposte**
+
+| HTTP | Significato |
+|------|-------------|
+| 200  | Documento salvato (corpo = documento MongoDB creato) |
+| 400  | Parametri mancanti (`namespace`, `question`, `answer`) |
+| 403  | Namespace non appartenente al progetto |
+| 500  | Errore server |
+
+---
+
+### `GET /:namespace`
+
+Elenco paginato delle domande risposte per il namespace.
+
+**Query**
+
+| Parametro    | Default | Descrizione |
+|--------------|---------|-------------|
+| `page`       | `0`     | Pagina (0-based) |
+| `limit`      | `20`    | Elementi per pagina |
+| `sortField`  | `created_at` | Campo ordinamento |
+| `direction`  | `-1`    | `1` crescente, `-1` decrescente |
+| `search`     | —       | Se presente, attiva ricerca **full-text** (`$text`); l’ordinamento usa lo score di testo |
+
+**Risposta 200**
+
+```json
+{
+  "count": 0,
+  "questions": [],
+  "query": {
+    "page": 0,
+    "limit": 20,
+    "sortField": "created_at",
+    "direction": -1,
+    "search": "..."
+  }
+}
+```
+
+**Altri codici:** `400` (namespace mancante), `403` (namespace non valido per il progetto), `500`.
+
+---
+
+### `DELETE /:id`
+
+Elimina una singola domanda per `_id` MongoDB.
+
+**Risposte:** `200` con `{ success, message }`, `404` se non trovata (o non del progetto), `500`.
+
+---
+
+### `DELETE /namespace/:namespace`
+
+Elimina **tutte** le domande risposte per `namespace` nel progetto corrente.
+
+**Risposta 200:** `{ success, count: <deletedCount>, message }`.
+
+**403** se il namespace non appartiene al progetto. **500** in errore.
+
+---
+
+### `GET /count/:namespace`
+
+Restituisce il conteggio documenti per `id_project` + `namespace`.
+
+**Risposta 200:** `{ count: <number> }`.
+
+**400** / **403** / **500** come negli altri endpoint con validazione namespace.
+
+---
+
+## Funzione interna `validateNamespace(id_project, namespace_id)`
+
+Verifica che esista un documento `Namespace` con `id_project` e `id: namespace_id`. Usata in creazione, lettura elenco, cancellazione bulk e conteggio.
+
+---
+
+## Nota sull’ordine delle route Express
+
+Nel file è definito `GET /:namespace` **prima** di `GET /count/:namespace`. In Express la prima route che corrisponde vince: una richiesta del tipo `GET .../kb/answered/count/<namespace>` può essere interpretata come `GET /:namespace` con `namespace` uguale alla stringa letterale `count`, invece che come endpoint di conteggio.
+
+Per far funzionare l’URL `GET /count/:namespace` come previsto dal codice, in genere occorre registrare **`GET /count/:namespace` prima di `GET /:namespace`**, oppure usare un prefisso path diverso per uno dei due. Verificare il comportamento in ambiente reale o adeguare l’ordine delle route se il conteggio non risponde come atteso.
+
+---
+
+## Riferimenti
+
+- Router: [`routes/answered.js`](../routes/answered.js)
+- Modello e indici: [`models/kb_setting.js`](../models/kb_setting.js) (`AnsweredQuestionSchema`)
+- Montaggio app: [`app.js`](../app.js) (`/:projectid/kb/answered`)

package/migrations/1757601159298-project_user_role_type.js

@@ -1,45 +1,104 @@
 var Project_user = require("../models/project_user");
 var winston = require('../config/winston');
 
+const BATCH_SIZE = 100;
+/** Log a progress line every this many bulkWrite rounds (plus always after the 1st). */
+const PROGRESS_LOG_EVERY_BATCHES = 10;
+
+/** Only documents that still need roleType (idempotent re-runs). */
+const WITHOUT_ROLE_TYPE = {
+  $or: [{ roleType: { $exists: false } }, { roleType: null }]
+};
+
+const AGENT_ROLES_FILTER = {
+  $and: [
+    {
+      $or: [
+        { role: 'agent' },
+        { role: 'supervisor' },
+        { role: 'admin' },
+        { role: 'owner' }
+      ]
+    },
+    WITHOUT_ROLE_TYPE
+  ]
+};
+
+const USER_ROLES_FILTER = {
+  $and: [{ $or: [{ role: 'user' }, { role: 'guest' }] }, WITHOUT_ROLE_TYPE]
+};
+
+async function batchSetRoleType(filter, roleType, phaseLabel) {
+  const totalMatching = await Project_user.countDocuments(filter);
+  const started = Date.now();
+  winston.info(
+    `[project_user_role_type] ${phaseLabel}: ${totalMatching} documents match filter; streaming _id + bulkWrite in chunks of ${BATCH_SIZE}`
+  );
+
+  let modified = 0;
+  let scanned = 0;
+  let bulkRounds = 0;
+  const cursor = Project_user.find(filter).select('_id').lean().cursor();
+  let batch = [];
+
+  function logProgress(reason) {
+    const elapsedSec = ((Date.now() - started) / 1000).toFixed(1);
+    winston.info(
+      `[project_user_role_type] ${phaseLabel} ${reason}: scanned=${scanned}/${totalMatching}, modifiedThisPhase=${modified}, ${elapsedSec}s elapsed`
+    );
+  }
+
+  for await (const doc of cursor) {
+    scanned++;
+    batch.push({
+      updateOne: {
+        filter: { _id: doc._id, ...WITHOUT_ROLE_TYPE },
+        update: { $set: { roleType } }
+      }
+    });
+    if (batch.length >= BATCH_SIZE) {
+      const result = await Project_user.bulkWrite(batch);
+      modified += result.modifiedCount;
+      batch = [];
+      bulkRounds++;
+      if (bulkRounds === 1 || bulkRounds % PROGRESS_LOG_EVERY_BATCHES === 0) {
+        logProgress(`progress (bulk round ${bulkRounds})`);
+      }
+    }
+  }
+  if (batch.length > 0) {
+    const result = await Project_user.bulkWrite(batch);
+    modified += result.modifiedCount;
+    bulkRounds++;
+    logProgress(`final partial batch (bulk round ${bulkRounds})`);
+  }
+
+  logProgress('phase complete');
+  return modified;
+}
+
 /**
  * Make any changes you need to make to the database here
  */
-async function up () {
-  let p = await Project_user.find({}).exec()
-  // Write migration here
-  await new Promise((resolve, reject) => {
-     Project_user.updateMany({"$or":[{ "role": "agent" }, { "role": "supervisor" }, { "role":  "admin" }, { "role": "owner" }]}, {"$set": {"roleType": 1 }}, function (err, updates) {
-      if (err) {
-        winston.error("Error appling the migration script", err);
-      }
-      winston.info("Schema updated for " + updates.nModified + " project_user of type agents")
-      winston.debug("updates",updates)      
-      //  return resolve('ok'); 
-    });  
-
-     return Project_user.updateMany({"$or":[{ "role": "user" }, { "role": "guest" }]}, {"$set": {"roleType": 2 }}, function (err, updates) {
-          if (err) {
-            winston.error("Error appling the migration script", err);
-          }
-          winston.info("Schema updated for " + updates.nModified + " project_user of type user"),
-          winston.debug("updates",updates)
-           return resolve('ok'); 
-        });  
-    
-  
-  });
-     
- 
-} 
-  
-/** 
+async function up() {
+  try {
+    const agentsModified = await batchSetRoleType(AGENT_ROLES_FILTER, 1, 'agents roleType=1');
+    winston.info(`[project_user_role_type] Agents phase done: ${agentsModified} documents modified`);
+
+    const usersModified = await batchSetRoleType(USER_ROLES_FILTER, 2, 'users/guest roleType=2');
+    winston.info(`[project_user_role_type] Users/guest phase done: ${usersModified} documents modified`);
+  } catch (err) {
+    winston.error('[project_user_role_type] Error applying migration:', err);
+    throw err;
+  }
+}
+
+/**
  * Make any changes that UNDO the up function side effects here (if possible)
  */
-async function down () {
-  
+async function down() {
   // Write migration here
   // console.log("down*********");
 }
 
-module.exports = { up, down }; 
-  
+module.exports = { up, down };

package/models/kb_setting.js

@@ -2,10 +2,24 @@ let mongoose = require('mongoose');
 let Schema = mongoose.Schema;
 let winston = require('../config/winston');
 
-const expireAfterSeconds = (() => {
-  const n = Number(process.env.UNANSWERED_QUESTION_EXPIRATION_TIME);
-  return !isNaN(n) && n >= 0 ? n : 7 * 24 * 60 * 60; // default 7 days
-})();
+const DEFAULT_UNANSWERED_TTL_SEC = 7 * 24 * 60 * 60; // 7 days
+const DEFAULT_ANSWERED_TTL_SEC = 7 * 24 * 60 * 60; // 7 days
+
+function ttlSecondsFromEnv(raw, fallbackSec) {
+  if (raw == null || String(raw).trim() === '') return fallbackSec;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : fallbackSec;
+}
+
+let expireAfterSeconds = ttlSecondsFromEnv(
+  process.env.UNANSWERED_QUESTION_EXPIRATION_TIME,
+  DEFAULT_UNANSWERED_TTL_SEC
+);
+let expireAnsweredAfterSeconds = ttlSecondsFromEnv(
+  process.env.ANSWERED_QUESTION_EXPIRATION_TIME,
+  DEFAULT_ANSWERED_TTL_SEC
+);
+
 
 const EngineSchema = new Schema({
   name: {
@@ -203,13 +217,63 @@ const UnansweredQuestionSchema = new Schema({
   question: {
     type: String,
     required: true
+  },
+  request_id: {
+    type: String,
+    required: false,
+  },
+  sender: {
+    type: String,
+    required: false,
   }
 },{
   timestamps: true
 });
 
-// Add TTL index to automatically delete documents after 30 days
-UnansweredQuestionSchema.index({ createdAt: 1 }, { expireAfterSeconds: expireAfterSeconds }); // 30 days
+const AnsweredQuestionSchema = new Schema({
+  id_project: {
+    type: String,
+    required: true,
+    index: true
+  },
+  namespace: {
+    type: String,
+    required: true,
+    index: true
+  },
+  question: {
+    type: String,
+    required: true
+  },
+  answer: {
+    type: String,
+    required: true
+  },
+  tokens: {
+    type: Number,
+    required: false
+  },
+  request_id: {
+    type: String,
+    required: false
+  }
+}, {
+  timestamps: true
+});
+
+// Add TTL index to automatically delete documents
+UnansweredQuestionSchema.index({ createdAt: 1 }, { expireAfterSeconds: expireAfterSeconds }); 
+UnansweredQuestionSchema.index({ id_project: 1, namespace: 1, createdAt: -1 });
+UnansweredQuestionSchema.index({ question: "text" });
+
+AnsweredQuestionSchema.index({ createdAt: 1 }, { expireAfterSeconds: expireAnsweredAfterSeconds });
+AnsweredQuestionSchema.index({ id_project: 1, namespace: 1, createdAt: -1 });
+AnsweredQuestionSchema.index(
+  { question: "text", answer: "text" },
+  { weights: { question: 3, answer: 1 } }
+);
+
+
 
 // DEPRECATED !! - Start
 const KBSettingSchema = new Schema({
@@ -246,6 +310,7 @@ const Engine = mongoose.model('Engine', EngineSchema)
 const Namespace = mongoose.model('Namespace', NamespaceSchema)
 const KB = mongoose.model('KB', KBSchema)
 const UnansweredQuestion = mongoose.model('UnansweredQuestion', UnansweredQuestionSchema)
+const AnsweredQuestion = mongoose.model('AnsweredQuestion', AnsweredQuestionSchema)
 
 
 module.exports = {
@@ -253,5 +318,6 @@ module.exports = {
   Namespace: Namespace,
   Engine: Engine,
   KB: KB,
-  UnansweredQuestion: UnansweredQuestion
+  UnansweredQuestion: UnansweredQuestion,
+  AnsweredQuestion: AnsweredQuestion
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.18.1",
+  "version": "2.18.3",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",

package/routes/answered.js

@@ -0,0 +1,227 @@
+const express = require('express');
+const router = express.Router();
+const { Namespace, AnsweredQuestion } = require('../models/kb_setting');
+const winston = require('../config/winston');
+
+// Add a new unanswerd question
+router.post('/', async (req, res) => {
+    try {
+        const { namespace, question, answer, tokens, request_id } = req.body;
+        const id_project = req.projectid;
+
+        if (!namespace || !question || !answer) {
+            return res.status(400).json({
+                success: false,
+                error: "Missing required parameters: namespace, question and answer"
+            })
+        }
+
+        // Check if namespae belongs to project
+        const isValidNamespace = await validateNamespace(id_project, namespace);
+        if (!isValidNamespace) {
+            return res.status(403).json({
+                success: false,
+                error: "Not allowed. The namespace does not belong to the current project."
+            })
+        }
+
+        const answeredQuestion = new AnsweredQuestion({
+            id_project,
+            namespace,
+            question,
+            answer,
+            tokens,
+            request_id,
+        });
+
+        const savedQuestion = await answeredQuestion.save();
+        res.status(200).json(savedQuestion);
+
+    } catch (error) {
+        winston.error('Error adding answered question:', error);
+        res.status(500).json({
+            success: false,
+            error: "Error adding answered question"
+        });
+    }
+})
+
+// Get all answered questions for a namespace
+router.get('/:namespace', async (req, res) => {
+
+    try {
+        const { namespace } = req.params;
+        const id_project = req.projectid;
+
+        if (!namespace) {
+            return res.status(400).json({
+                success: false,
+                error: "Missing required parameter: namespace"
+            })
+        }
+
+        // Check if namespace belongs to project
+        const isValidNamespace = await validateNamespace(id_project, namespace);
+        if (!isValidNamespace) {
+            return res.status(403).json({
+                success: false,
+                error: "Not allowed. The namespace does not belong to the current project."
+            })
+        }
+        
+        const page = parseInt(req.query.page) || 0;
+        const limit = parseInt(req.query.limit) || 20;
+        const sortField = req.query.sortField || 'created_at';
+        const direction = parseInt(req.query.direction) || -1;
+
+        const filter = { id_project, namespace };
+
+        let projection = undefined;
+
+        if (req.query.search) {
+            filter.$text = { $search: req.query.search };
+            // Add score to projection if it's a text search
+            projection = { score: { $meta: "textScore" } };
+        }
+
+        let sortObj;
+        if (projection && projection.score) {
+            sortObj = { score: { $meta: "textScore" } };
+        } else {
+            sortObj = { [sortField]: direction };
+        }
+
+        const questions = await AnsweredQuestion.find(filter, projection)
+            .sort(sortObj)
+            .skip(page * limit)
+            .limit(limit);
+
+        const count = await AnsweredQuestion.countDocuments(filter);
+
+        res.status(200).json({
+            count,
+            questions,
+            query: {
+                page,
+                limit,
+                sortField,
+                direction,
+                search: req.query.search || undefined
+            }
+        });
+        
+    } catch (error) {
+        winston.error('Error getting answered questions:', error);
+        res.status(500).json({
+            success: false,
+            error: "Error getting answered questions"
+        });
+    }
+
+})
+
+router.delete('/:id', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const id_project = req.projectid;
+
+        const deleted = await AnsweredQuestion.findOneAndDelete({ _id: id, id_project });
+        if (!deleted) {
+            return res.status(404).json({
+                success: false,
+                error: "Question not found"
+            });
+        }
+
+        res.status(200).json({
+            success: true,
+            message: "Question deleted successfully"
+        });
+
+    } catch (error) {
+        winston.error('Error deleting answered question:', error);
+        res.status(500).json({
+            success: false,
+            error: "Error deleting answered question"
+        });
+    }
+})
+
+router.delete('/namespace/:namespace', async (req, res) => {
+    try {
+        const { namespace } = req.params;
+        const id_project = req.projectid;
+
+        // Check if namespace belongs to project
+        const isValidNamespace = await validateNamespace(id_project, namespace);
+        if (!isValidNamespace) {
+            return res.status(403).json({
+                success: false,
+                error: "Not allowed. The namespace does not belong to the current project."
+            });
+        }
+        
+        const result = await AnsweredQuestion.deleteMany({ id_project, namespace });
+        res.status(200).json({
+            success: true,
+            count: result.deletedCount,
+            message: "All questions deleted successfully"
+        });
+
+    } catch (error) {
+        winston.error('Error deleting answered questions:', error);
+        res.status(500).json({
+            success: false,
+            error: "Error deleting answered questions"
+        });
+    }
+})
+
+router.get('/count/:namespace', async (req, res) => {
+    try {
+        const { namespace } = req.params;
+        const id_project = req.projectid;
+
+        if (!namespace) {
+            return res.status(400).json({
+                success: false,
+                error: "Missing required parameter: namespace"
+            });
+        }
+
+        // Check if namespace belongs to project
+        const isValidNamespace = await validateNamespace(id_project, namespace);
+        if (!isValidNamespace) {
+            return res.status(403).json({
+                success: false,
+                error: "Not allowed. The namespace does not belong to the current project."
+            });
+        }
+
+        const count = await AnsweredQuestion.countDocuments({ id_project, namespace });
+        res.status(200).json({ count });
+
+    } catch (error) {
+        winston.error('Error counting answered questions:', error);
+        res.status(500).json({
+            success: false,
+            error: "Error counting answered questions"
+        });
+    }
+})
+
+// Helper function to validate namespace
+async function validateNamespace(id_project, namespace_id) {
+    try {
+        const namespace = await Namespace.findOne({
+            id_project: id_project,
+            id: namespace_id
+        });
+        return !!namespace;
+    } catch (err) {
+        winston.error('validate namespace error: ', err);
+        throw err;
+    }
+}
+
+module.exports = router;

package/routes/unanswered.js

@@ -6,7 +6,7 @@ var winston = require('../config/winston');
 // Add a new unanswered question
 router.post('/', async (req, res) => {
     try {
-        const { namespace, question } = req.body;
+        const { namespace, question, request_id, sender } = req.body;
         const id_project = req.projectid;
 
         if (!namespace || !question) {
@@ -28,7 +28,9 @@ router.post('/', async (req, res) => {
         const unansweredQuestion = new UnansweredQuestion({
             id_project,
             namespace,
-            question
+            question,
+            request_id,
+            sender
         });
 
         const savedQuestion = await unansweredQuestion.save();
@@ -70,18 +72,29 @@ router.get('/:namespace', async (req, res) => {
         const sortField = req.query.sortField || 'createdAt';
         const direction = parseInt(req.query.direction) || -1;
 
-        const questions = await UnansweredQuestion.find({
-            id_project,
-            namespace
-        })
-        .sort({ [sortField]: direction })
-        .skip(page * limit)
-        .limit(limit);
+        const filter = { id_project, namespace };
 
-        const count = await UnansweredQuestion.countDocuments({
-            id_project,
-            namespace
-        });
+        let projection = undefined;
+
+        if (req.query.search) {
+            filter.$text = { $search: req.query.search };
+            // Add score to projection if it's a text search
+            projection = { score: { $meta: "textScore" } };
+        }
+
+        let sortObj;
+        if (projection && projection.score) {
+            sortObj = { score: { $meta: "textScore" } };
+        } else {
+            sortObj = { [sortField]: direction };
+        }
+
+        const questions = await UnansweredQuestion.find(filter, projection)
+            .sort(sortObj)
+            .skip(page * limit)
+            .limit(limit);
+
+        const count = await UnansweredQuestion.countDocuments(filter);
 
         res.status(200).json({
             count,
@@ -90,7 +103,8 @@ router.get('/:namespace', async (req, res) => {
                 page,
                 limit,
                 sortField,
-                direction
+                direction,
+                search: req.query.search || undefined
             }
         });
 
@@ -109,20 +123,19 @@ router.delete('/:id', async (req, res) => {
         const { id } = req.params;
         const id_project = req.projectid;
 
-        const question = await UnansweredQuestion.findOne({ _id: id, id_project });
-        if (!question) {
+        const deleted = await UnansweredQuestion.findOneAndDelete({ _id: id, id_project });
+        if (!deleted) {
             return res.status(404).json({
                 success: false,
                 error: "Question not found"
             });
         }
 
-        await UnansweredQuestion.deleteOne({ _id: id });
         res.status(200).json({
             success: true,
             message: "Question deleted successfully"
         });
-
+        
     } catch (error) {
         winston.error('Error deleting unanswered question:', error);
         res.status(500).json({