@tiledesk/tiledesk-server 2.28.2 → 3.0.0

package/test/v3FlowService.js

@@ -0,0 +1,187 @@
+process.env.NODE_ENV = 'test';
+process.env.LOG_LEVEL = 'error';
+
+const chai = require('chai');
+const expect = chai.expect;
+
+const v3 = require('../services/v3FlowService');
+const templates = require('../template/chatbot');
+
+/** Blocks written the V2 way with fixed ids, so the list can be compared with the Design Studio's. */
+function fixedBlank() {
+    return [
+        { intent_id: 'fallback-id', intent_display_name: 'defaultFallback', actions: [], attributes: { position: { x: 0, y: 0 }, nextBlockAction: { _tdActionId: 'dot-id', _tdActionType: 'intent', intentName: '#msg-id' } } },
+        { intent_id: 'msg-id', intent_display_name: 'untitled_block_2', actions: [{ _tdActionId: 'reply-id', _tdActionType: 'reply', text: 'I did not understand', attributes: { commands: [] } }], attributes: { position: { x: 0, y: 0 } } },
+        { intent_id: 'start-id', intent_display_name: 'start', question: '\\start', actions: [{ _tdActionId: 'intent-id', _tdActionType: 'intent', intentName: '#welcome-id' }], attributes: { position: { x: 0, y: 0 } } },
+        { intent_id: 'welcome-id', intent_display_name: 'welcome', actions: [{ _tdActionId: 'welcome-reply-id', _tdActionType: 'reply', text: 'Hi', attributes: { commands: [] } }], attributes: { position: { x: 0, y: 0 } } }
+    ];
+}
+
+describe('v3FlowService', () => {
+
+    describe('toV3Flow', () => {
+
+        it('builds the list with the Design Studio ids and clears the V2 destinations', () => {
+            const flow = v3.toV3Flow(fixedBlank(), () => '2026-10-15T00:00:00.000Z');
+            expect(flow.connectors).to.deep.equal({
+                version: 1,
+                updatedAt: '2026-10-15T00:00:00.000Z',
+                items: [
+                    { id: 'fallback-id/dot-id/msg-id', from: { intentId: 'fallback-id', actionId: 'dot-id', slot: 'next' }, to: { intentId: 'msg-id' }, kind: 'block' },
+                    { id: 'start-id/intent-id/welcome-id', from: { intentId: 'start-id', actionId: 'intent-id', slot: 'default' }, to: { intentId: 'welcome-id' }, kind: 'action' }
+                ]
+            });
+            const fallback = flow.intents[0];
+            expect(fallback.attributes.nextBlockAction).to.deep.equal({ _tdActionId: 'dot-id', _tdActionType: 'intent' });
+            expect(flow.intents[2].actions[0]).to.not.have.property('intentName');
+        });
+
+        it('fills in the technical ids a template leaves out, so every record has an anchor', () => {
+            const flow = v3.toV3Flow(JSON.parse(JSON.stringify(templates.blank({}))));
+            flow.intents.forEach((intent) => {
+                expect(intent.intent_id).to.be.a('string').that.is.not.empty;
+                intent.actions.forEach((action) => expect(action._tdActionId).to.be.a('string').that.is.not.empty);
+            });
+            expect(flow.connectors.items).to.have.lengthOf(2);
+            flow.connectors.items.forEach((record) => {
+                expect(record.from.actionId).to.be.a('string').that.is.not.empty;
+                expect(flow.intents.some((intent) => intent.intent_id === record.to.intentId)).to.equal(true);
+            });
+            expect(v3.validateConnectors(flow.connectors)).to.deep.equal([]);
+        });
+
+        it('converts every server template without errors', () => {
+            Object.keys(templates).forEach((name) => {
+                const flow = v3.toV3Flow(JSON.parse(JSON.stringify(templates[name]({}))));
+                expect(v3.validateConnectors(flow.connectors), name).to.deep.equal([]);
+                flow.connectors.items.forEach((record) => {
+                    expect(flow.intents.some((intent) => intent.intent_id === record.to.intentId), name + ' ' + record.id).to.equal(true);
+                });
+            });
+        });
+
+        it('covers true/false, cases, branches, buttons and the iteration, and keeps a button\'s params', () => {
+            const intents = [
+                { intent_id: 'a', intent_display_name: 'a', actions: [
+                    { _tdActionId: 'c1', _tdActionType: 'jsoncondition2', trueIntent: '#b', falseIntent: '#c' },
+                    { _tdActionId: 'm1', _tdActionType: 'jsonconditionmulti', cases: [{ _tdCaseId: 'k1', intent: '#b' }, { _tdCaseId: 'k2', intent: '' }], elseIntent: '#c' },
+                    { _tdActionId: 'ai1', _tdActionType: 'ai_condition', intents: [{ label: 'yes', conditionIntentId: '#b' }], fallbackIntent: '#c', errorIntent: '' },
+                    { _tdActionId: 'it1', _tdActionType: 'iteration', goToIntent: '#b', fallbackIntent: '#c' },
+                    { _tdActionId: 'r1', _tdActionType: 'reply', attributes: { commands: [{ type: 'message', message: { attributes: { attachment: { buttons: [
+                        { uid: 'u1', type: 'action', value: 'go', action: '#b{"x":1}' },
+                        { uid: 'u2', type: 'text', value: 'plain' },
+                        { uid: 'u3', type: 'url', value: 'site', link: 'https://x' }
+                    ] } } } }] } }
+                ], attributes: {} },
+                { intent_id: 'b', intent_display_name: 'b', actions: [], attributes: {} },
+                { intent_id: 'c', intent_display_name: 'c', actions: [], attributes: {} }
+            ];
+            const flow = v3.toV3Flow(intents, () => 'now');
+            expect(flow.connectors.items.map((r) => r.id)).to.deep.equal([
+                'a/c1/true/b', 'a/c1/false/c',
+                'a/m1/case/k1/b', 'a/m1/else/c',
+                'a/ai1/yes/true/b', 'a/ai1/fallback/c',
+                'a/it1/goto/b', 'a/it1/fallback/c',
+                'a/r1/u1/b'
+            ]);
+            expect(flow.connectors.items.map((r) => r.kind)).to.deep.equal(['action', 'action', 'case', 'action', 'branch', 'action', 'action', 'action', 'button']);
+            expect(flow.connectors.items.map((r) => r.from.slot)).to.deep.equal(['true', 'false', 'case:k1', 'else', 'branch:yes', 'fallback', 'goto', 'fallback', 'button:u1']);
+            expect(flow.connectors.items[8].props).to.deep.equal({ params: '{"x":1}' });
+            const a = flow.intents[0];
+            expect(a.actions[0]).to.not.have.property('trueIntent');
+            expect(a.actions[1].cases[1]).to.not.have.property('intent');
+            expect(a.actions[2]).to.not.have.property('errorIntent');
+            const buttons = a.actions[4].attributes.commands[0].message.attributes.attachment.buttons;
+            expect(buttons[0]).to.not.have.property('action');
+            expect(buttons[0].type).to.equal('action');
+            expect(buttons[2].link).to.equal('https://x');
+        });
+
+        it('leaves a bare block name and a target to a block that does not exist out of the list', () => {
+            const intents = [
+                { intent_id: 'a', intent_display_name: 'a', actions: [{ _tdActionId: 'i1', _tdActionType: 'intent', intentName: 'welcome' }], attributes: { nextBlockAction: { _tdActionId: 'd1', _tdActionType: 'intent', intentName: '#ghost' } } },
+                { intent_id: 'w', intent_display_name: 'welcome', actions: [], attributes: {} }
+            ];
+            const flow = v3.toV3Flow(intents);
+            expect(flow.connectors.items).to.deep.equal([]);
+            expect(flow.intents[0].actions[0].intentName).to.equal('welcome');
+            expect(flow.intents[0].attributes.nextBlockAction).to.not.have.property('intentName');
+        });
+
+        it('does not give a "Return to parent agent" block a dot connector', () => {
+            const intents = [
+                { intent_id: 'r', intent_display_name: 'return', actions: [{ _tdActionId: 'rs', _tdActionType: 'returnstack' }], attributes: { nextBlockAction: { _tdActionId: 'd', _tdActionType: 'intent', intentName: '#x' } } },
+                { intent_id: 'x', intent_display_name: 'x', actions: [], attributes: {} }
+            ];
+            expect(v3.toV3Flow(intents).connectors.items).to.deep.equal([]);
+        });
+    });
+
+    describe('validateConnectors', () => {
+        const good = { id: 'a/b/c', from: { intentId: 'a', actionId: 'b', slot: 'next' }, to: { intentId: 'c' }, kind: 'block' };
+
+        it('accepts a well formed list, with or without updatedAt and props', () => {
+            expect(v3.validateConnectors({ version: 1, items: [] })).to.deep.equal([]);
+            expect(v3.validateConnectors({ version: 1, updatedAt: '2026-10-15T10:00:00.000Z', items: [{ ...good, props: { label: 'x' } }] })).to.deep.equal([]);
+        });
+
+        it('names what is wrong', () => {
+            expect(v3.validateConnectors(null)).to.have.lengthOf(1);
+            expect(v3.validateConnectors({ version: 2, items: [] })[0]).to.match(/version/);
+            expect(v3.validateConnectors({ version: 1 })[0]).to.match(/items/);
+            expect(v3.validateConnectors({ version: 1, updatedAt: 'yesterday', items: [] })[0]).to.match(/updatedAt/);
+            expect(v3.validateConnectors({ version: 1, items: [{ ...good, kind: 'line' }] })[0]).to.match(/kind/);
+            expect(v3.validateConnectors({ version: 1, items: [{ ...good, id: 'z/b/c' }] })[0]).to.match(/does not match/);
+            expect(v3.validateConnectors({ version: 1, items: [good, good] })[0]).to.match(/duplicated/);
+            expect(v3.validateConnectors({ version: 1, items: [{ ...good, from: { intentId: 'a' } }] })[0]).to.match(/from/);
+            expect(v3.validateConnectors({ version: 1, items: [{ ...good, props: 'x' }] })[0]).to.match(/props/);
+        });
+    });
+
+    describe('promoteLegacyJson', () => {
+
+        it('moves dsVersion and connectors out of attributes, for the sub agents too', () => {
+            const json = {
+                attributes: { dsVersion: ' V3 ', connectors: { version: 1, items: [] }, globals: [] },
+                subagents: [{ attributes: { dsVersion: 'v3' } }]
+            };
+            expect(v3.promoteLegacyJson(json)).to.equal(true);
+            expect(json.ds_version).to.equal('v3');
+            expect(json.connectors).to.deep.equal({ version: 1, items: [] });
+            expect(json.attributes).to.deep.equal({ globals: [] });
+            expect(json.subagents[0].ds_version).to.equal('v3');
+            expect(json.subagents[0].attributes).to.deep.equal({});
+        });
+
+        it('keeps the fields when both forms are present, and drops an unknown label', () => {
+            const json = { ds_version: 'v3', connectors: { version: 1, items: [] }, attributes: { dsVersion: 'v2', connectors: { version: 1, items: [{}] } } };
+            v3.promoteLegacyJson(json);
+            expect(json.ds_version).to.equal('v3');
+            expect(json.connectors.items).to.deep.equal([]);
+            const unknown = { ds_version: 'v9', attributes: {} };
+            v3.promoteLegacyJson(unknown);
+            expect(unknown).to.not.have.property('ds_version');
+        });
+
+        it('leaves a V2 JSON alone', () => {
+            const json = { name: 'v2', attributes: { globals: [] }, intents: [] };
+            expect(v3.promoteLegacyJson(json)).to.equal(false);
+            expect(json).to.deep.equal({ name: 'v2', attributes: { globals: [] }, intents: [] });
+        });
+    });
+
+    describe('normalizeDsVersion and legacyAttributeKeys', () => {
+        it('recognises the V3 label in any spelling and nothing else', () => {
+            expect(v3.normalizeDsVersion('v3')).to.equal('v3');
+            expect(v3.normalizeDsVersion(' V3 ')).to.equal('v3');
+            expect(v3.normalizeDsVersion('v4')).to.equal(undefined);
+            expect(v3.normalizeDsVersion(3)).to.equal(undefined);
+            expect(v3.normalizeDsVersion(undefined)).to.equal(undefined);
+        });
+        it('lists the legacy keys a patch of the attributes carries', () => {
+            expect(v3.legacyAttributeKeys({ dsVersion: 'v3', connectors: {}, notes: [] })).to.deep.equal(['dsVersion', 'connectors']);
+            expect(v3.legacyAttributeKeys({ notes: [] })).to.deep.equal([]);
+            expect(v3.legacyAttributeKeys(null)).to.deep.equal([]);
+        });
+    });
+});

package/test/webhookRoute.js

@@ -16,6 +16,7 @@ let server = require('../app');
 let should = chai.should();
 var fs = require('fs');
 const path = require('path');
+const { ChatbotService } = require('../services/chatbotService');
 
 var expect = chai.expect;
 var assert = chai.assert;
@@ -543,7 +544,7 @@ describe('WebhookRoute', () => {
         userService.signup(email, pwd, "Test Firstname", "Test lastname").then(function (savedUser) {
             projectService.create("test-webhook-create", savedUser._id).then(function (savedProject) {
 
-                class chatbot_service {
+                class chatbot_service extends ChatbotService {
                     async fork(id_faq_kb, api_url, token, project_id) {
                         let forked_bot_id = id_faq_kb.substr(id_faq_kb, id_faq_kb.length - 4) + "1111";
                         return { bot_id: forked_bot_id }

package/utils/AppError.js

@@ -0,0 +1,9 @@
+class AppError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "AppError";
+  }
+}
+
+module.exports = AppError;

package/utils/asyncHandler.js

@@ -0,0 +1,10 @@
+/**
+ * Wraps an async route handler so rejected promises are forwarded to Express error middleware.
+ */
+function asyncHandler(fn) {
+  return function (req, res, next) {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+}
+
+module.exports = asyncHandler;