@tiledesk/tiledesk-server 2.28.2 → 2.29.0

package/controllers/intents.controller.js

@@ -0,0 +1,139 @@
+const Intent = require("../models/faq");
+const AppError = require("../utils/AppError");
+const faqBotEvent = require("../event/faqBotEvent");
+const winston = require("../config/winston");
+
+const INTENT_FIELDS = [
+  "intent_display_name",
+  "intent_id",
+  "question",
+  "answer",
+  "reply",
+  "form",
+  "enabled",
+  "webhook_enabled",
+  "language",
+  "actions",
+  "attributes"
+];
+
+class IntentsController {
+
+  constructor() { }
+
+  _mapIntent(chatbot_id, id_project, user_id, intent) {
+    const mapped = {
+      id_faq_kb: chatbot_id,
+      id_project,
+      createdBy: user_id
+    };
+    for (const field of INTENT_FIELDS) {
+      if (intent[field] !== undefined) {
+        mapped[field] = intent[field];
+      }
+    }
+    return mapped;
+  }
+
+  async create(chatbot_id, id_project, user_id, intent, { skipDuplicates = false } = {}) {
+    try {
+      const faq = await Intent.create(
+        this._mapIntent(chatbot_id, id_project, user_id, intent)
+      );
+      faqBotEvent.emit("faq.create", faq);
+      return faq;
+    } catch (err) {
+      if (err.code === 11000) {
+        if (skipDuplicates) {
+          winston.debug("Skip duplicated intent_display_name");
+          return null;
+        }
+        throw new AppError(409, "Duplicate intent_display_name");
+      }
+      winston.error("(IntentsController) create error: ", err);
+      throw new AppError(500, "Error creating intent");
+    }
+  }
+
+  async createMany(chatbot_id, id_project, user_id, intents, options) {
+    if (!intents?.length) {
+      return [];
+    }
+    const results = await Promise.allSettled(
+      intents.map((intent) =>
+        this.create(chatbot_id, id_project, user_id, intent, options)
+      )
+    );
+    return results
+      .filter((r) => r.status === "fulfilled" && r.value)
+      .map((r) => r.value);
+  }
+
+  async upsert(chatbot_id, id_project, user_id, intent) {
+    try {
+      const savingResult = await Intent.findOneAndUpdate(
+        { id_faq_kb: chatbot_id, intent_display_name: intent.intent_display_name },
+        this._mapIntent(chatbot_id, id_project, user_id, intent),
+        { new: true, upsert: true, rawResult: true }
+      );
+
+      if (!savingResult?.value) {
+        return null;
+      }
+
+      if (savingResult.lastErrorObject?.updatedExisting === true) {
+        winston.verbose("updated existing intent");
+        faqBotEvent.emit("faq.update", savingResult.value);
+      } else {
+        winston.verbose("new intent created");
+        faqBotEvent.emit("faq.create", savingResult.value);
+      }
+
+      return savingResult.value;
+    } catch (err) {
+      winston.error("(IntentsController) upsert error: ", err);
+      throw new AppError(500, "Error upserting intent");
+    }
+  }
+
+  async upsertMany(chatbot_id, id_project, user_id, intents) {
+    if (!intents?.length) {
+      return [];
+    }
+    const results = await Promise.allSettled(
+      intents.map((intent) =>
+        this.upsert(chatbot_id, id_project, user_id, intent)
+      )
+    );
+    return results
+      .filter((r) => r.status === "fulfilled" && r.value)
+      .map((r) => r.value);
+  }
+
+  async deleteByChatbotId(chatbot_id) {
+    try {
+      const result = await Intent.deleteMany({ id_faq_kb: chatbot_id });
+      winston.verbose("All faq for chatbot " + chatbot_id + " deleted successfully");
+      return result;
+    } catch (err) {
+      winston.error("(IntentsController) deleteByChatbotId error: ", err);
+      throw new AppError(500, `Error deleting intents for chatbot ${chatbot_id}`);
+    }
+  }
+
+  async getIntents(chatbot_id) {
+    try {
+      const intents = await Intent
+        .find({ id_faq_kb: chatbot_id })
+        .lean()
+        .exec();
+      return intents;
+    } catch (err) {
+      winston.error("(IntentsController) getIntents error: ", err);
+      throw new AppError(500, `Error finding intents with chatbot id ${chatbot_id}`);
+    }
+  }
+}
+
+const intentsController = new IntentsController();
+module.exports = intentsController;

package/errorCodes.js

@@ -29,7 +29,8 @@ const errorCodes = {
   CHATBOT: {
     BASE_CODE: 12000,
     ERRORS: {
-      DUPLICATE_SLUG: 12001
+      DUPLICATE_SLUG: 12001,
+      SUBAGENT_IN_USE: 12002
     }
   },
   WEBHOOK: {

package/event/botEvent.js

@@ -135,7 +135,9 @@ class BotEvent extends EventEmitter {
                 return;
             }
 
-            await Faq.updateMany({ id_faq_kb: chatbot._id }, { trashed: true, trashedAt: chatbot.trashedAt }).catch((err) => {
+            const trashedAt = chatbot.trashedAt || new Date();
+
+            await Faq.updateMany({ id_faq_kb: chatbot._id }, { trashed: true, trashedAt: trashedAt }).catch((err) => {
                 winston.error("Event faqbot.update.virtual.delete error updating faqs ", err);
             })
 
@@ -143,6 +145,9 @@ class BotEvent extends EventEmitter {
                 winston.error("Error deleting webhook on chatbot deleting: ", err);
             })
 
+            // Soft-delete subagents of the draft chatbot (+ their intents) so TTL applies
+            await trashSubagentsByParentIds([chatbot._id], trashedAt);
+
             let publishedChatbots = await Faq_kb.find({ root_id: chatbot._id }, { _id: 1 }).catch((err) => {
                 winston.error("Event faqbot.update.virtual.delete error getting all published chatbots ", err);
             })
@@ -161,13 +166,16 @@ class BotEvent extends EventEmitter {
                 for (const batch of batches) {
                     await Faq_kb.updateMany(
                         { _id: { $in: batch } },
-                        { $set: { trashed: true, trashedAt: chatbot.trashedAt } }
+                        { $set: { trashed: true, trashedAt: trashedAt } }
                     );
 
                     await Faq.updateMany(
                         { id_faq_kb: { $in: batch } },
-                        { $set: { trashed: true, trashedAt: chatbot.trashedAt } }
+                        { $set: { trashed: true, trashedAt: trashedAt } }
                     );
+
+                    // Soft-delete subagents linked to published copies (+ their intents)
+                    await trashSubagentsByParentIds(batch, trashedAt);
                 
                     await sleep(sleep_ms);
                 }                
@@ -175,6 +183,38 @@ class BotEvent extends EventEmitter {
             }
         })
 
+        async function trashSubagentsByParentIds(parentIds, trashedAt) {
+            if (!parentIds || parentIds.length === 0) {
+                return;
+            }
+
+            const parentIdStrings = parentIds.map(id => id.toString());
+            let subagents = await Faq_kb.find({ parent_id: { $in: parentIdStrings } }, { _id: 1 }).catch((err) => {
+                winston.error("Event faqbot.update.virtual.delete error getting subagents ", err);
+                return [];
+            });
+
+            if (!subagents || subagents.length === 0) {
+                return;
+            }
+
+            const subagentIds = subagents.map(s => s._id);
+
+            await Faq_kb.updateMany(
+                { _id: { $in: subagentIds } },
+                { $set: { trashed: true, trashedAt: trashedAt } }
+            ).catch((err) => {
+                winston.error("Event faqbot.update.virtual.delete error updating subagents ", err);
+            });
+
+            await Faq.updateMany(
+                { id_faq_kb: { $in: subagentIds } },
+                { $set: { trashed: true, trashedAt: trashedAt } }
+            ).catch((err) => {
+                winston.error("Event faqbot.update.virtual.delete error updating subagent faqs ", err);
+            });
+        }
+
         function sleep(ms) {
             return new Promise(resolve => setTimeout(resolve, ms));
           }

package/middleware/errorHandler.js

@@ -0,0 +1,41 @@
+const AppError = require('../utils/AppError');
+const winston = require('../config/winston');
+
+function errorHandler(err, req, res, next) {
+  if (err instanceof AppError) {
+    winston.error(err.message, err);
+    return res.status(err.status).json({
+      success: false,
+      message: err.message
+    });
+  }
+
+  winston.debug("err.name", err.name);
+  if (err.name === "IpDeniedError") {
+    winston.debug("IpDeniedError");
+    return res.status(401).json({ err: "error ip filter" });
+  }
+
+  const realIp = req.headers['x-forwarded-for']?.split(',')[0] || req.headers['x-real-ip'] || req.ip;
+
+  // emitted by multer when the file is too big
+  if (err.code === "LIMIT_FILE_SIZE") {
+    winston.debug("LIMIT_FILE_SIZE");
+    winston.warn(`LIMIT_FILE_SIZE on ${req.originalUrl}`, {
+      limit: process.env.MAX_UPLOAD_FILE_SIZE,
+      ip: req.ip,
+      realIp: realIp
+    });
+    return res.status(413).json({ err: "Content Too Large", limit_file_size: process.env.MAX_UPLOAD_FILE_SIZE });
+  }
+
+  if (err.type === "entity.too.large" || err.name === "PayloadTooLargeError") {
+    winston.warn("Payload too large", { expected: err.expected, limit: err.limit, length: err.length });
+    return res.status(413).json({ err: "Request entity too large", limit: err.limit });
+  }
+
+  winston.error("General error: ", err);
+  return res.status(500).json({ err: "error" });
+}
+
+module.exports = errorHandler;

package/models/chatbotTemplates.js

@@ -18,5 +18,9 @@ module.exports = {
     voice_twilio: {
         default: 'blank_voice_twilio',
         templates: ['empty', 'blank_voice_twilio']
+    },
+    subagent: {
+        default: 'blank_subagent',
+        templates: ['empty', 'blank_subagent']
     }
 }

package/models/faq.js

@@ -192,6 +192,16 @@ FaqSchema.index(
   { partialFilterExpression: { "actions.namespace": { $exists: true } } }
 );
 
+FaqSchema.index(
+  { "actions.botId": 1 },
+  { partialFilterExpression: { "actions.botId": { $exists: true } } }
+);
+
+FaqSchema.index(
+  { "actions.botSlug": 1 },
+  { partialFilterExpression: { "actions.botSlug": { $exists: true } } }
+);
+
 FaqSchema.index(
   { trashedAt: 1 },
   { expireAfterSeconds: trashExpirationTime }

package/models/faq_kb.js

@@ -161,6 +161,10 @@ var Faq_kbSchema = new Schema({
   release_note: {
     type: String,
     required: false
+  },
+  parent_id: {
+    type: String,
+    required: false
   }
 },{
   timestamps: true
@@ -248,6 +252,16 @@ Faq_kbSchema.index(
   { unique: true, partialFilterExpression: { slug: { $exists: true } } }
 );
 
+Faq_kbSchema.index(
+  { id_project: 1, subtype: 1 },
+  { partialFilterExpression: { subtype: { $ne: "subagent" } } }
+);
+
+Faq_kbSchema.index(
+  { id_project: 1, parent_id: 1 },
+  { partialFilterExpression: { parent_id: { $exists: true } } }
+);
+
 Faq_kbSchema.index(
   { trashedAt: 1 },
   { expireAfterSeconds: trashExpirationTime }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.28.2",
+  "version": "2.29.0",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",
@@ -49,7 +49,7 @@
     "@tiledesk/tiledesk-rasa-connector": "^1.0.10",
     "@tiledesk/tiledesk-sms-connector": "^0.1.13",
     "@tiledesk/tiledesk-telegram-connector": "^0.1.14",
-    "@tiledesk/tiledesk-tybot-connector": "^2.1.15",
+    "@tiledesk/tiledesk-tybot-connector": "^2.3.0",
     "@tiledesk/tiledesk-voice-twilio-connector": "^0.3.2",
     "@tiledesk/tiledesk-vxml-connector": "^0.1.91",
     "@tiledesk/tiledesk-whatsapp-connector": "1.0.31",