@tiledesk/tiledesk-tybot-connector 2.1.2 → 2.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-tybot-connector",
-  "version": "2.1.2",
+  "version": "2.1.5",
   "description": "Tiledesk Tybot connector",
   "main": "index.js",
   "scripts": {

package/services/DataTablesService.js

@@ -0,0 +1,180 @@
+const httpUtils = require('../utils/HttpUtils');
+const winston = require('../utils/winston');
+const API_ENDPOINT = process.env.API_ENDPOINT;
+
+class DataTablesService {
+
+  constructor() { }
+
+  /**
+   * GET /{projectId}/tables/{tableId}/rows/list
+   * @param {string} projectId
+   * @param {string} tableId
+   * @param {string} token
+   * @param {object} [options]
+   * @param {'all'|'any'} [options.must_match]
+   * @param {'all'|'any'} [options.match] - alias di must_match
+   * @param {Array<{column: string, operator: string, value?: *}>} [options.conditions]
+   */
+  async listRows(projectId, tableId, token, options = {}) {
+    return new Promise((resolve, reject) => {
+      const params = {};
+      if (options.must_match) {
+        params.must_match = options.must_match;
+      }
+      if (options.match) {
+        params.match = options.match;
+      }
+      if (options.conditions && options.conditions.length > 0) {
+        params.conditions = JSON.stringify(options.conditions);
+      }
+
+      const http_request = {
+        url: `${API_ENDPOINT}/${projectId}/tables/${tableId}/rows/list`,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'JWT ' + token
+        },
+        params,
+        method: 'GET'
+      };
+      winston.debug('DataTablesService listRows', http_request);
+
+      httpUtils.request(http_request, (err, response) => {
+        if (err) {
+          winston.error('DataTablesService listRows error:', err?.response?.data || err);
+          reject(err);
+        } else {
+          resolve(response);
+        }
+      });
+    });
+  }
+
+  /**
+   * POST /{projectId}/tables/{tableId}/row/insert
+   * @param {string} projectId
+   * @param {string} tableId
+   * @param {string} token
+   * @param {{ data: object, id_row?: string }} body
+   */
+  async insertRow(projectId, tableId, token, body) {
+    return new Promise((resolve, reject) => {
+      const http_request = {
+        url: `${API_ENDPOINT}/${projectId}/tables/${tableId}/row/insert`,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'JWT ' + token
+        },
+        json: body,
+        method: 'POST'
+      };
+      winston.debug('DataTablesService insertRow', http_request);
+
+      httpUtils.request(http_request, (err, response) => {
+        if (err) {
+          winston.error('DataTablesService insertRow error:', err?.response?.data || err);
+          reject(err);
+        } else {
+          resolve(response);
+        }
+      });
+    });
+  }
+
+  /**
+   * PUT /{projectId}/tables/{tableId}/row/update
+   * @param {string} projectId
+   * @param {string} tableId
+   * @param {string} token
+   * @param {{ id_row?: string, must_match?: string, match?: string, conditions?: Array, data: object }} body
+   */
+  async updateRow(projectId, tableId, token, body) {
+    return new Promise((resolve, reject) => {
+      const http_request = {
+        url: `${API_ENDPOINT}/${projectId}/tables/${tableId}/row/update`,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'JWT ' + token
+        },
+        json: body,
+        method: 'PUT'
+      };
+      winston.debug('DataTablesService updateRow', http_request);
+
+      httpUtils.request(http_request, (err, response) => {
+        if (err) {
+          winston.error('DataTablesService updateRow error:', err?.response?.data || err);
+          reject(err);
+        } else {
+          resolve(response);
+        }
+      });
+    });
+  }
+
+  /**
+   * PUT /{projectId}/tables/{tableId}/row/upsert
+   * @param {string} projectId
+   * @param {string} tableId
+   * @param {string} token
+   * @param {{ id_row?: string, must_match?: string, match?: string, conditions?: Array, data: object, multi?: boolean }} body
+   */
+  async upsertRow(projectId, tableId, token, body) {
+    return new Promise((resolve, reject) => {
+      const http_request = {
+        url: `${API_ENDPOINT}/${projectId}/tables/${tableId}/row/upsert`,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'JWT ' + token
+        },
+        json: body,
+        method: 'PUT'
+      };
+      winston.debug('DataTablesService upsertRow', http_request);
+
+      httpUtils.request(http_request, (err, response) => {
+        if (err) {
+          winston.error('DataTablesService upsertRow error:', err?.response?.data || err);
+          reject(err);
+        } else {
+          resolve(response);
+        }
+      });
+    });
+  }
+
+  /**
+   * PUT /{projectId}/tables/{tableId}/row/delete
+   * @param {string} projectId
+   * @param {string} tableId
+   * @param {string} token
+   * @param {{ id_row?: string, must_match?: string, match?: string, conditions?: Array }} body
+   */
+  async deleteRow(projectId, tableId, token, body) {
+    return new Promise((resolve, reject) => {
+      const http_request = {
+        url: `${API_ENDPOINT}/${projectId}/tables/${tableId}/row/delete`,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'JWT ' + token
+        },
+        json: body,
+        method: 'PUT'
+      };
+      winston.debug('DataTablesService deleteRow', http_request);
+
+      httpUtils.request(http_request, (err, response) => {
+        if (err) {
+          winston.error('DataTablesService deleteRow error:', err?.response?.data || err);
+          reject(err);
+        } else {
+          resolve(response);
+        }
+      });
+    });
+  }
+}
+
+const dataTablesService = new DataTablesService();
+module.exports = dataTablesService;

package/tiledeskChatbotPlugs/DirectivesChatbotPlug.js

@@ -22,6 +22,7 @@ const { DirIfOpenHours } = require('./directives/DirIfOpenHours');
 const { DirAssignFromFunction } = require('./directives/DirAssignFromFunction');
 const { DirCondition } = require('./directives/DirCondition');
 const { DirJSONCondition } = require('./directives/DirJSONCondition');
+const { DirJSONConditionV2 } = require('./directives/DirJSONConditionV2');
 const { DirAssign } = require('./directives/DirAssign');
 const { DirSetAttribute } = require('./directives/DirSetAttribute');
 const { DirSetAttributeV2 } = require('./directives/DirSetAttributeV2');
@@ -64,6 +65,7 @@ const { DirFlowLog } = require('./directives/DirFlowLog');
 const { DirAddKbContent } = require('./directives/DirAddKbContent');
 const { DirIteration } = require('./directives/DirIteration');
 const { AnalyticsClient } = require('../AnalyticsClient');
+const { DirDataTables } = require('./directives/DirDataTables');
 
 class DirectivesChatbotPlug {
 
@@ -182,14 +184,17 @@ class DirectivesChatbotPlug {
     const go_on = await TiledeskChatbot.checkStep(this.context.tdcache, this.context.requestId, this.chatbot?.MAX_STEPS,  this.chatbot?.MAX_EXECUTION_TIME);
 
     if (go_on.error) {
-      AnalyticsClient.track('agent.flow_error', this.context.projectId, {
-        agent_id: this.chatbot?.bot.root_id || this.chatbot?.botId,
-        error_type:    go_on.error_code || 'runtime_error',
-        error_message: go_on.error || null,
-        step_count:    go_on.step_count || 0,
-        intent_name:   this.context.reply?.attributes?.intent_info?.intent_name || null,
-        request_id:    this.context.requestId || null
-      });
+      // Only track published (production) runs (root/draft copy has no root_id).
+      if (this.chatbot?.bot.root_id) {
+        AnalyticsClient.track('agent.flow_error', this.context.projectId, {
+          agent_id: this.chatbot?.bot.root_id,
+          error_type:    go_on.error_code || 'runtime_error',
+          error_message: go_on.error || null,
+          step_count:    go_on.step_count || 0,
+          intent_name:   this.context.reply?.attributes?.intent_info?.intent_name || null,
+          request_id:    this.context.requestId || null
+        });
+      }
       winston.debug("(DirectivesChatbotPlug) go_on == false! nextDirective() Stopped!");
       return this.errorMessage(go_on.error); //"Request error: anomaly detection. MAX ACTIONS exeeded.");
     }
@@ -261,6 +266,7 @@ class DirectivesChatbotPlug {
       [Directives.IF_ONLINE_AGENTS_V2]: DirIfOnlineAgentsV2,
       [Directives.FUNCTION_VALUE]: DirAssignFromFunction,
       [Directives.JSON_CONDITION]: DirJSONCondition,
+      [Directives.JSON_CONDITION_2]: DirJSONConditionV2, // NEW: JSON Condition V2 (tipo dedicato dal DS); V1 dispatch invariato
       [Directives.ASSIGN]: DirAssign,
       [Directives.SET_ATTRIBUTE]: DirSetAttribute,
       [Directives.SET_ATTRIBUTE_V2]: DirSetAttributeV2,
@@ -304,6 +310,7 @@ class DirectivesChatbotPlug {
       [Directives.WEB_RESPONSE]: DirWebResponse,
       [Directives.FLOW_LOG]: DirFlowLog,
       [Directives.ITERATION]: DirIteration,
+      [Directives.DATA_TABLES]: DirDataTables,
     };
 
     const HandlerClass = handlers[directive_name];
@@ -318,17 +325,29 @@ class DirectivesChatbotPlug {
 
     const blockStart = Date.now();
     handler.execute(directive, async (stop) => {
-      AnalyticsClient.track('agent.block_executed', this.context.projectId, {
-        agent_id:       this.context.chatbot?.bot.root_id || this.context.chatbot?.botId || '',
-        block_id:       directive.action?.["_tdActionId"] || '',
-        block_name:     directive.action?.["_tdActionTitle"] || directive.action?.name || 'unnamed',
-        directive_type: directive.name || 'unknown',
-        intent_id:      this.context.chatbot?._lastIntentId || '',
-        intent_name:    this.context.reply?.attributes?.intent_info?.intent_name || null,
-        duration_ms:    Date.now() - blockStart,
-        success:        !stop,
-        request_id:     this.context.requestId || null
-      });
+      // [analytics-debug] Trace the block_executed decision per directive so we can
+      // see whether the event is emitted and why (missing root_id, draft, etc.).
+      winston.debug("(DirectivesChatbotPlug) [analytics] block_executed decision:" +
+        " directive_type=" + (directive.name || 'unknown') +
+        " block_id=" + (directive.action?.["_tdActionId"] || '<empty>') +
+        " root_id=" + (this.context.chatbot?.bot?.root_id || '<none>') +
+        " draft=" + (this.context.supportRequest?.draft) +
+        " stop=" + stop +
+        " willEmit=" + (!!this.context.chatbot?.bot?.root_id));
+      // Only track published (production) runs (root/draft copy has no root_id).
+      if (this.context.chatbot?.bot.root_id) {
+        AnalyticsClient.track('agent.block_executed', this.context.projectId, {
+          agent_id:       this.context.chatbot?.bot.root_id,
+          block_id:       directive.action?.["_tdActionId"] || '',
+          block_name:     directive.action?.["_tdActionTitle"] || directive.action?.name || 'unnamed',
+          directive_type: directive.name || 'unknown',
+          intent_id:      this.context.chatbot?._lastIntentId || '',
+          intent_name:    this.context.reply?.attributes?.intent_info?.intent_name || null,
+          duration_ms:    Date.now() - blockStart,
+          success:        !stop,
+          request_id:     this.context.requestId || null
+        });
+      }
       if (stop) {
         winston.debug(`(DirectivesChatbotPlug) Stopping Actions on:`, directive);
         return this.theend();

package/tiledeskChatbotPlugs/directives/DirAiCondition.js

@@ -195,7 +195,7 @@ class DirAiCondition {
       max_tokens: action.max_tokens,
       id_project: this.projectId,
       request_id: this.requestId,
-      agent_id: this.chatbot?.bot.root_id || this.chatbot?.botId
+      agent_id: this.chatbot?.bot.root_id || null
     }
 
     if (action.context) {

package/tiledeskChatbotPlugs/directives/DirAiPrompt.js

@@ -256,7 +256,7 @@ class DirAiPrompt {
       max_tokens: action.max_tokens,
       id_project: this.projectId,
       request_id: this.requestId,
-      agent_id: this.chatbot?.bot.root_id || this.chatbot?.botId
+      agent_id: this.chatbot?.bot.root_id || null
     }
 
     if (action.context) {

package/tiledeskChatbotPlugs/directives/DirAskGPT.js

@@ -133,7 +133,7 @@ class DirAskGPT {
       question: filled_question,
       kbid: action.kbid,
       gptkey: key,
-      agent_id: this.chatbot?.bot.root_id || this.chatbot?.botId,
+      agent_id: this.chatbot?.bot.root_id || null,
       id_project: this.projectId,
       request_id: this.requestId
     };

package/tiledeskChatbotPlugs/directives/DirAskGPTV2.js

@@ -296,7 +296,7 @@ class DirAskGPTV2 {
       stream: false,
       id_project: this.projectId,
       request_id: this.requestId,
-      agent_id: this.chatbot?.bot.root_id || this.chatbot?.botId,
+      agent_id: this.chatbot?.bot.root_id || null,
     };
     if (top_k) {
       json.top_k = top_k;

package/tiledeskChatbotPlugs/directives/DirDataTables.js

@@ -0,0 +1,293 @@
+const { TiledeskChatbot } = require("../../engine/TiledeskChatbot");
+const { Filler } = require("../Filler");
+const { DirIntent } = require("./DirIntent");
+const winston = require('../../utils/winston');
+const { Logger } = require("../../Logger");
+const dataTablesService = require("../../services/DataTablesService");
+
+const SUPPORTED_OPERATIONS = ['get', 'insert', 'update', 'delete', 'upsert'];
+const ROW_DOCUMENT_OPERATIONS = ['insert', 'update', 'delete', 'upsert'];
+
+class DirDataTables {
+
+  constructor(context) {
+    if (!context) {
+      throw new Error('context object is mandatory.');
+    }
+    this.context = context;
+    this.chatbot = context.chatbot;
+    this.tdcache = context.tdcache;
+    this.requestId = context.requestId;
+    this.projectId = context.projectId;
+    this.token = context.token;
+    this.API_ENDPOINT = context.API_ENDPOINT;
+
+    this.intentDir = new DirIntent(context);
+    this.logger = new Logger({ request_id: this.requestId, dev: this.context.supportRequest?.draft, intent_id: this.context.reply?.intent_id || this.context.reply?.attributes?.intent_info?.intent_id });
+  }
+
+  execute(directive, callback) {
+    winston.debug("DirDataTables directive: ", directive);
+    let action;
+    if (directive.action) {
+      action = directive.action;
+    }
+    else {
+      this.logger.error("Incorrect action for ", directive.name, directive);
+      winston.debug("DirDataTables Incorrect directive: ", directive);
+      callback();
+      return;
+    }
+    this.go(action, (stop) => {
+      this.logger.native("[DataTables] Executed");
+      callback(stop);
+    });
+  }
+
+  async go(action, callback) {
+    winston.debug("DirDataTables action: ", action);
+    if (!this.tdcache) {
+      winston.error("DirDataTables Error: tdcache is mandatory");
+      callback();
+      return;
+    }
+
+    const trueIntent = action.trueIntent;
+    const falseIntent = action.falseIntent;
+    const trueIntentAttributes = action.trueIntentAttributes;
+    const falseIntentAttributes = action.falseIntentAttributes;
+
+    const requestVariables = await TiledeskChatbot.allParametersStatic(this.tdcache, this.requestId);
+    const filler = new Filler();
+
+    const tableId = filler.fill(action.tableId, requestVariables);
+    const operation = action.operation;
+
+    if (!tableId) {
+      const error = "tableId is required";
+      this.logger.error("[DataTables] " + error);
+      await this.#assignAttributes(action, null, error);
+      if (falseIntent) {
+        await this.#executeCondition(false, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes);
+        callback(true);
+        return;
+      }
+      callback();
+      return;
+    }
+
+    if (!operation || !SUPPORTED_OPERATIONS.includes(operation)) {
+      const error = `operation must be one of: ${SUPPORTED_OPERATIONS.join(', ')}`;
+      this.logger.error("[DataTables] " + error);
+      await this.#assignAttributes(action, null, error);
+      if (falseIntent) {
+        await this.#executeCondition(false, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes);
+        callback(true);
+        return;
+      }
+      callback();
+      return;
+    }
+
+    try {
+      let result;
+      switch (operation) {
+        case 'get':
+          result = await dataTablesService.listRows(this.projectId, tableId, this.token, {
+            must_match: action.must_match,
+            conditions: this.#fillConditions(action.conditions, filler, requestVariables)
+          });
+          break;
+        case 'insert':
+          result = await dataTablesService.insertRow(this.projectId, tableId, this.token, {
+            data: this.#fillData(action.data, filler, requestVariables),
+            ...(action.id_row ? { id_row: filler.fill(action.id_row, requestVariables) } : {})
+          });
+          break;
+        case 'update':
+          result = await dataTablesService.updateRow(this.projectId, tableId, this.token, this.#buildMutationBody(action, filler, requestVariables));
+          break;
+        case 'delete':
+          result = await dataTablesService.deleteRow(this.projectId, tableId, this.token, this.#buildDeleteBody(action, filler, requestVariables));
+          break;
+        case 'upsert':
+          result = await dataTablesService.upsertRow(this.projectId, tableId, this.token, {
+            ...this.#buildMutationBody(action, filler, requestVariables),
+            ...(action.multi !== undefined ? { multi: action.multi } : {})
+          });
+          break;
+      }
+
+      this.logger.native("[DataTables] operation " + operation + " completed");
+      await this.#assignAttributes(action, this.#normalizeResult(result, operation), null);
+      if (trueIntent) {
+        await this.#executeCondition(true, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes);
+        callback(true);
+        return;
+      }
+      callback();
+    } catch (err) {
+      const error = this.#extractError(err);
+      this.logger.error("[DataTables] " + operation + " error: ", error);
+      winston.error("DirDataTables error:", err?.response?.data || err);
+      await this.#assignAttributes(action, null, error);
+      if (falseIntent) {
+        await this.#executeCondition(false, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes);
+        callback(true);
+        return;
+      }
+      callback();
+    }
+  }
+
+  #fillConditions(conditions, filler, requestVariables) {
+    if (!conditions || !Array.isArray(conditions) || conditions.length === 0) {
+      return undefined;
+    }
+    return conditions.map((condition) => {
+      const filled = { ...condition };
+      if (filled.value !== undefined && filled.value !== null) {
+        filled.value = filler.fill(String(filled.value), requestVariables);
+      }
+      return filled;
+    });
+  }
+
+  #fillData(data, filler, requestVariables) {
+    if (!data || typeof data !== 'object') {
+      return {};
+    }
+    const filled = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (value === null || value === undefined) {
+        filled[key] = value;
+      } else if (typeof value === 'string') {
+        filled[key] = filler.fill(value, requestVariables);
+      } else {
+        filled[key] = value;
+      }
+    }
+    return filled;
+  }
+
+  #buildMutationBody(action, filler, requestVariables) {
+    const body = {
+      data: this.#fillData(action.data, filler, requestVariables)
+    };
+    if (action.id_row) {
+      body.id_row = filler.fill(action.id_row, requestVariables);
+    }
+    if (action.must_match) {
+      body.must_match = action.must_match;
+    }
+    const conditions = this.#fillConditions(action.conditions, filler, requestVariables);
+    if (conditions) {
+      body.conditions = conditions;
+    }
+    return body;
+  }
+
+  #buildDeleteBody(action, filler, requestVariables) {
+    const body = {};
+    if (action.id_row) {
+      body.id_row = filler.fill(action.id_row, requestVariables);
+    }
+    if (action.must_match) {
+      body.must_match = action.must_match;
+    }
+    const conditions = this.#fillConditions(action.conditions, filler, requestVariables);
+    if (conditions) {
+      body.conditions = conditions;
+    }
+    return body;
+  }
+
+  #normalizeResult(result, operation) {
+    if (!ROW_DOCUMENT_OPERATIONS.includes(operation) || result === undefined || result === null) {
+      return result;
+    }
+    if (Array.isArray(result)) {
+      return result.map((row) => this.#extractRowData(row));
+    }
+    return this.#extractRowData(result);
+  }
+
+  #extractRowData(row) {
+    if (row && row.data !== undefined && row.data !== null && typeof row.data === 'object' && !Array.isArray(row.data)) {
+      return row.data;
+    }
+    return row;
+  }
+
+  #extractError(err) {
+    if (err?.response?.data?.message) {
+      return err.response.data.message;
+    }
+    if (err?.response?.data?.error) {
+      return err.response.data.error;
+    }
+    if (err?.response?.data) {
+      return typeof err.response.data === 'string' ? err.response.data : JSON.stringify(err.response.data);
+    }
+    if (err?.message) {
+      return err.message;
+    }
+    return String(err);
+  }
+
+  async #executeCondition(result, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes, callback) {
+    let trueIntentDirective = null;
+    if (trueIntent) {
+      trueIntentDirective = DirIntent.intentDirectiveFor(trueIntent, trueIntentAttributes);
+    }
+    let falseIntentDirective = null;
+    if (falseIntent) {
+      falseIntentDirective = DirIntent.intentDirectiveFor(falseIntent, falseIntentAttributes);
+    }
+    if (result === true) {
+      if (trueIntentDirective) {
+        this.logger.native("[DataTables] executing true condition");
+        this.intentDir.execute(trueIntentDirective, () => {
+          if (callback) {
+            callback();
+          }
+        });
+      }
+      else {
+        winston.debug("DirDataTables No trueIntentDirective specified");
+        if (callback) {
+          callback();
+        }
+      }
+    }
+    else {
+      if (falseIntentDirective) {
+        this.logger.native("[DataTables] executing false condition");
+        this.intentDir.execute(falseIntentDirective, () => {
+          if (callback) {
+            callback();
+          }
+        });
+      }
+      else {
+        winston.debug("DirDataTables No falseIntentDirective specified");
+        if (callback) {
+          callback();
+        }
+      }
+    }
+  }
+
+  async #assignAttributes(action, result, error) {
+    if (this.context.tdcache) {
+      if (action.assignResultTo && result !== undefined && result !== null) {
+        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.assignResultTo, result);
+      }
+      if (action.assignErrorTo && error) {
+        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.assignErrorTo, error);
+      }
+    }
+  }
+}
+
+module.exports = { DirDataTables };