wingbot 3.27.2 → 3.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.27.2",
+  "version": "3.30.0",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "scripts": {
@@ -36,33 +36,28 @@
   },
   "homepage": "https://github.com/wingbot.ai/wingbot#readme",
   "devDependencies": {
-    "cpy-cli": "^3.1.1",
-    "eslint": "^7.12.1",
-    "eslint-config-airbnb": "^18.2.0",
-    "eslint-mocha": "^0.7.3",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-jsdoc": "^30.7.7",
-    "eslint-plugin-jsx-a11y": "^6.4.1",
-    "eslint-plugin-mocha": "^8.0.0",
-    "eslint-plugin-react": "^7.21.5",
-    "gitbook-cli": "^2.3.2",
-    "graphql-markdown": "^5.2.0",
-    "graphql-tools": "^7.0.5",
-    "jsdoc-to-markdown": "^6.0.1",
-    "mocha": "^8.2.1",
-    "move-cli": "^1.2.1",
+    "cpy-cli": "^4.1.0",
+    "eslint": "^8.11.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-jsdoc": "^38.0.4",
+    "eslint-plugin-jsx-a11y": "^6.5.1",
+    "eslint-plugin-mocha": "^10.0.3",
+    "eslint-plugin-react": "^7.29.4",
+    "graphql-markdown": "^6.0.0",
+    "jsdoc-to-markdown": "^7.1.1",
+    "mocha": "^9.2.2",
     "nyc": "^15.1.0",
     "rimraf": "^3.0.2",
-    "sinon": "^9.2.1",
+    "sinon": "^13.0.1",
     "tsd-jsdoc": "^2.5.0"
   },
   "dependencies": {
-    "graphql": "^15.4.0",
-    "graphql-mongodb-projection": "^1.1.1",
+    "graphql": "^15.8.0",
     "jsonwebtoken": "^8.5.1",
-    "node-fetch": "^2.6.1",
+    "node-fetch": "^2.6.7",
     "path-to-regexp": "^6.2.0",
-    "uuid": "^8.3.1",
+    "uuid": "^8.3.2",
     "webalize": "^0.1.0"
   },
   "optionalDependencies": {

package/plugins/ai.wingbot.goBack/plugin.js

@@ -3,7 +3,7 @@
  * @param {import('../../src/Responder')} res
  * @param {Function} postback
  */
-module.exports = (req, res, postback) => {
+module.exports = function (req, res, postback) {
     if (req.state.beforeLastInteraction
         && !req.state.beforeLastInteraction.match(/\/\*$/)
         && req.state.beforeLastInteraction !== res.currentAction()) {

package/plugins/ai.wingbot.goToLastBreadcrumb/plugin.js

@@ -3,7 +3,7 @@
  * @param {import('../../src/Responder')} res
  * @param {Function} postback
  */
-module.exports = (req, res, postback) => {
+module.exports = function (req, res, postback) {
     let { breadcrumbs = [] } = req.state;
     let shift = req.state.breadcrumbAction === req.state._lastAction
         ? 2

package/plugins/ai.wingbot.jumpBack/plugin.js

@@ -3,7 +3,7 @@
  * @param {import('../../src/Responder')} res
  * @param {Function} postback
  */
-module.exports = (req, res, postback) => {
+module.exports = function (req, res, postback) {
     let { jumpPluginStack = [] } = {
         ...req.state,
         ...res.newState

package/plugins/ai.wingbot.jumpTo/plugin.js

@@ -3,7 +3,7 @@
  * @param {import('../../src/Responder')} res
  * @param {Function} postback
  */
-module.exports = (req, res, postback) => {
+module.exports = function (req, res, postback) {
     const {
         whereToJump,
         whereToJumpBack

package/plugins/ai.wingbot.stopResponding/plugin.js

@@ -2,4 +2,6 @@
  * @param {import('../../src/Request')} req
  * @param {import('../../src/Responder')} res
  */
-module.exports = (req, res) => null;
+module.exports = function (req, res) {
+    return null;
+};

package/src/Ai.js

@@ -64,6 +64,20 @@ class Ai {
          */
         this.threshold = 0.3;
 
+        /**
+         * Upper limit for NLP resolving of STT alternatives
+         *
+         * @type {number}
+         */
+        this.sttMaxAlternatives = 3;
+
+        /**
+         * Minimal score to consider text as recognized well
+         *
+         * @type {number}
+         */
+        this.sttScoreThreshold = 0;
+
         /**
          * The logger (console by default)
          *
@@ -581,35 +595,61 @@ class Ai {
             }
         }
 
+        const texts = req.textAlternatives()
+            .filter((alt) => alt.score >= this.sttScoreThreshold)
+            .slice(0, this.sttMaxAlternatives);
+
+        const altMax = Math.max(0, ...texts.map((t) => t.score));
+        const altKoef = (1 - this.confidence);
+
         const results = await Promise.all(
-            req.textAlternatives()
-                .map(({ text, score }) => model
-                    .resolve(this.textFilter(text), req)
-                    .then((res) => ({
-                        ...res,
-                        _altScore: score
-                    })))
+            texts.map(({ text, score }) => model
+                .resolve(this.textFilter(text), req)
+                .then((res) => ({
+                    ...res,
+                    intents: res.intents
+                        .map((i) => ({
+                            ...i,
+                            score: i.score - (altKoef * (altMax - score))
+                        }))
+                        .sort(({ score: a }, { score: z }) => z - a)
+                })))
         );
 
         results.sort(({
-            intents: aIntents = [], _altScore: aAlt
+            intents: [aIntent = { score: 0 }]
         }, {
-            intents: zIntents = [], _altScore: zAlt
-        }) => {
-            const [{ score: aScore = 0 } = {}] = aIntents;
-            const [{ score: zScore = 0 } = {}] = zIntents;
+            intents: [zIntent = { score: 0 }]
+        }) => zIntent.score - aIntent.score);
 
-            const a = aAlt * aScore;
-            const z = zAlt * zScore;
+        const [winner = { intents: [], entities: [] }, ...others] = results;
 
-            if (a === z) {
-                return zAlt - aAlt;
-            }
+        if (others.length === 0) {
+            return winner;
+        }
 
-            return z - a;
+        const { intents } = winner;
+
+        const known = new Set(intents.map((i) => i.intent));
+
+        others.forEach((other) => {
+            intents.push(
+                ...other.intents.filter(({ score, intent }) => {
+                    if (score >= this.confidence || known.has(intent)) {
+                        return false;
+                    }
+                    known.add(intent);
+                    return true;
+                })
+            );
         });
 
-        return results[0];
+        intents.sort(({ score: a }, { score: z }) => z - a);
+
+        return {
+            ...winner,
+            intents
+        };
     }
 
     /**

package/src/AiMatching.js

@@ -53,12 +53,16 @@ const COMPARE = {
  * @param {Entity[]} [entities]
  */
 
+/**
+ * @typedef {string|number|Function} Comparable
+ */
+
 /**
  * @typedef {object} EntityExpression
  * @prop {string} entity - the requested entity
  * @prop {boolean} [optional] - the match is optional
  * @prop {Compare} [op] - comparison operation
- * @prop {(string|number|Function)[]} [compare] - value to compare
+ * @prop {Comparable[]} [compare] - value to compare
  */
 
 /**
@@ -578,10 +582,12 @@ class AiMatching {
                         score: 1
                     };
 
-                    matching = this
-                        ._entityIsMatching(
-                            wanted.op, wanted.compare, requestEntity.value, requestState
-                        );
+                    matching = this._entityIsMatching(
+                        wanted.op,
+                        wanted.compare,
+                        requestEntity.value,
+                        requestState
+                    );
                 }
             } else if (!entityExists) {
                 matching = this

package/src/BotApp.js

@@ -87,14 +87,12 @@ class BotApp {
         this._senderLogger = chatLogStorage;
         this._verify = promisify(jwt.verify);
 
-        this._processor = new Processor(
-            bot, {
-                ...processorOptions,
-                secret,
-                fetch: this._fetch,
-                apiUrl: gqlApiUrl
-            }
-        );
+        this._processor = new Processor(bot, {
+            ...processorOptions,
+            secret,
+            fetch: this._fetch,
+            apiUrl: gqlApiUrl
+        });
 
         this._processor.plugin(BotApp.plugin());
         this._preferSynchronousResponse = preferSynchronousResponse;
@@ -191,7 +189,13 @@ class BotApp {
     }
 
     async _processIncommingMessage (
-        message, senderId, pageId, appId, secret, sync = false, headers = {}
+        message,
+        senderId,
+        pageId,
+        appId,
+        secret,
+        sync = false,
+        headers = {}
     ) {
         const { mid = null } = message;
 
@@ -386,7 +390,13 @@ class BotApp {
 
                     for (const message of messaging) {
                         const res = await this._processIncommingMessage(
-                            message, senderId, pageId, appId, secret, sync, headers
+                            message,
+                            senderId,
+                            pageId,
+                            appId,
+                            secret,
+                            sync,
+                            headers
                         );
 
                         responses.push(res);

package/src/ConversationTester.js

@@ -305,9 +305,8 @@ class ConversationTester {
         return testCases
             // @ts-ignore
             .reduce(
-                (map, testCase) => map.set(
-                    testCase.list, [...(map.get(testCase.list) || []), testCase]
-                ),
+                (map, testCase) => map
+                    .set(testCase.list, [...(map.get(testCase.list) || []), testCase]),
                 new Map()
             );
     }

package/src/OrchestratorClient.js

@@ -77,11 +77,9 @@ class OrchestratorClient {
      */
     async addConversationTokenToUrl (url, expirationInSeconds, tokenName = 'wbchtoken') {
         const { conversationToken } = await this.getConversationToken(expirationInSeconds);
-        return withParams(
-            url, {
-                query: { [tokenName]: conversationToken }
-            }
-        );
+        return withParams(url, {
+            query: { [tokenName]: conversationToken }
+        });
     }
 
     /**

package/src/Processor.js

@@ -100,7 +100,7 @@ const { mergeState } = require('./utils/stateVariables');
  * @prop {string|null} [meta.targetAction]
  */
 
-const NAME_FROM_STATE = (state) => {
+function NAME_FROM_STATE (state) {
     if (state.user && state.user.firstName) {
         return `${state.user.firstName} ${state.user.lastName}`;
     }
@@ -108,7 +108,7 @@ const NAME_FROM_STATE = (state) => {
         return `${state.user.name}`;
     }
     return null;
-};
+}
 
 /**
  * Messaging event processor

package/src/Request.js

@@ -742,18 +742,36 @@ class Request {
         if (!this.message || typeof this.message.text !== 'string') {
             return [];
         }
-        const { text, alternatives = [] } = this.message;
+        const { text: messageText, alternatives = [] } = this.message;
+
+        const unique = new Set();
+        let max = 0;
+
+        const sorted = alternatives
+            .slice()
+            .map(({ text, score = 1 }) => ({ text, score }))
+            .sort(({ score: a }, { score: z }) => z - a)
+            .filter((a) => {
+                const norm = tokenize(a.text);
+                if (unique.has(norm) || !a.text) {
+                    return false;
+                }
+                max = Math.max(max, a.score);
+                unique.add(norm);
+                return true;
+            });
+
+        const normalized = tokenize(messageText);
 
-        if (alternatives.some((a) => a.text === text)) {
-            return alternatives;
+        if (unique.has(normalized)) {
+            return sorted;
         }
 
+        max = max ? Math.min(1, max + 0.1) : 1;
+
         return [
-            {
-                text: this.message.text,
-                score: 1
-            },
-            ...alternatives
+            { text: messageText, score: max },
+            ...sorted
         ];
     }
 
@@ -1268,7 +1286,9 @@ class Request {
         if (this._quickReplyActions === null) {
             if (this.state._expectedKeywords) {
                 this._quickReplyActions = quickReplyAction(
-                    this.state._expectedKeywords, this, Ai.ai
+                    this.state._expectedKeywords,
+                    this,
+                    Ai.ai
                 );
             } else {
                 this._quickReplyActions = [];
@@ -1411,7 +1431,8 @@ It looks like the bot isn't connected to class BotApp or the Processor is used w
         data = {},
         refAction = null,
         refData = {},
-        timestamp = makeTimestamp()
+        timestamp = makeTimestamp(),
+        features = [FEATURE_TEXT]
     ) {
         const postback = {
             payload: {
@@ -1429,7 +1450,8 @@ It looks like the bot isn't connected to class BotApp or the Processor is used w
             sender: {
                 id: senderId
             },
-            postback
+            postback,
+            features
         };
     }
 
@@ -1725,4 +1747,24 @@ It looks like the bot isn't connected to class BotApp or the Processor is used w
 
 }
 
+/**
+ * @constant {string} FEATURE_VOICE channel supports voice messages
+ */
+Request.FEATURE_VOICE = FEATURE_VOICE;
+
+/**
+ * @constant {string} FEATURE_SSML channel supports SSML voice messages
+ */
+Request.FEATURE_SSML = FEATURE_SSML;
+
+/**
+ * @constant {string} FEATURE_PHRASES channel supports expected phrases messages
+ */
+Request.FEATURE_PHRASES = FEATURE_PHRASES;
+
+/**
+ * @constant {string} FEATURE_TEXT channel supports text communication
+ */
+Request.FEATURE_TEXT = FEATURE_TEXT;
+
 module.exports = Request;

package/src/Tester.js

@@ -14,6 +14,8 @@ const AnyResponseAssert = require('./testTools/AnyResponseAssert');
 const ResponseAssert = require('./testTools/ResponseAssert');
 
 const Router = require('./Router'); // eslint-disable-line no-unused-vars
+const ReducerWrapper = require('./ReducerWrapper'); // eslint-disable-line no-unused-vars
+const { FEATURE_TEXT } = require('./features');
 
 /**
  * Utility for testing requests
@@ -118,6 +120,11 @@ class Tester {
          * @prop {console} use own loggger
          */
         this.senderLogger = undefined;
+
+        /**
+         * @prop {string[]}
+         */
+        this.features = null;
     }
 
     dealloc () {
@@ -148,6 +155,15 @@ class Tester {
         this._responsesMock = [];
     }
 
+    /**
+     * Set features for all messages
+     *
+     * @param {string[]} [features]
+     */
+    setFeatures (features = [FEATURE_TEXT]) {
+        this.features = features;
+    }
+
     /**
      * Use tester as a connector :)
      *
@@ -164,6 +180,10 @@ class Tester {
             });
         }
 
+        if (this.features) {
+            Object.assign(message, { features: this.features });
+        }
+
         const messageSender = new ReturnSender({}, senderId, message, this.senderLogger);
         messageSender.simulatesOptIn = true;
 
@@ -259,7 +279,7 @@ class Tester {
     }
 
     /**
-     * Checks, that a plugin used a block as a responde
+     * Checks, that a plugin used a block as a response
      *
      * @param {string} blockName
      * @returns {this}
@@ -308,7 +328,6 @@ class Tester {
      *
      * @param {string} text
      * @returns {Promise}
-     *
      * @memberOf Tester
      */
     text (text) {
@@ -430,12 +449,11 @@ class Tester {
      * @param {string} [refAction=null] - referred action
      * @param {object} [refData={}] - referred action data
      * @returns {Promise}
-     *
      * @memberOf Tester
      */
     postBack (action, data = {}, refAction = null, refData = {}) {
         return this.processMessage(Request
-            .postBack(this.senderId, action, data, refAction, refData));
+            .postBack(this.senderId, action, data, refAction, refData, null));
     }
 
 }

package/src/graphApi/schema.gql

@@ -13,6 +13,7 @@ type Tags {
 type Subscribtion {
     pageId: String
     senderId: String
+    meta: String
 }
 
 type Subscribtions {

package/src/notifications/Notifications.js

@@ -103,6 +103,28 @@ const DEFAULT_CAMPAIGN_DATA = {
  * @prop {number} slideRound
  */
 
+/**
+ * @typedef {object} Subscription
+ * @prop {string} senderId
+ * @prop {string} pageId
+ * @prop {string} [meta]
+ */
+
+/**
+ * @callback PreprocessSubscriptions
+ * @param {Subscription[]} subscriptions
+ * @param {string} pageId
+ * @returns {Promise<Subscription[]>|Subscription[]}
+ */
+
+/**
+ * @callback PreprocessSubscribers
+ * @param {string[]} senderIds
+ * @param {string} pageId
+ * @param {string} tag
+ * @returns {Promise<string[]>|string[]} list of senderIds
+ */
+
 /**
  * Experimental notifications service
  *
@@ -121,7 +143,8 @@ class Notifications extends EventEmitter {
      * @param {console} [options.log] - logger
      * @param {number} [options.default24Clearance] - use this clearance to ensure delivery in 24h
      * @param {string} [options.allAudienceTag] - tag to mark all users
-     * @param {Function} [options.preprocessSubscribers] - to preprocess GQL api given senderIds
+     * @param {PreprocessSubscribers} [options.preprocessSubscribers] - preprocess senderIds import
+     * @param {PreprocessSubscriptions} [options.preprocessSubscriptions]
      */
     constructor (notificationStorage = new NotificationsStorage(), options = {}) {
         super();
@@ -138,6 +161,7 @@ class Notifications extends EventEmitter {
         this._lts = new Map();
 
         this._preprocessSubscribers = options.preprocessSubscribers;
+        this._preprocessSubscriptions = options.preprocessSubscriptions;
     }
 
     /**
@@ -150,7 +174,8 @@ class Notifications extends EventEmitter {
      */
     api (acl = null) {
         const options = {
-            preprocessSubscribers: this._preprocessSubscribers
+            preprocessSubscribers: this._preprocessSubscribers,
+            preprocessSubscriptions: this._preprocessSubscriptions
         };
         return api(this._storage, this, acl, options);
     }
@@ -344,7 +369,10 @@ class Notifications extends EventEmitter {
 
         await Promise.all(tasks
             .map((task) => this._messageDeliveryByMid(
-                task.campaignId, eventType, senderId, pageId
+                task.campaignId,
+                eventType,
+                senderId,
+                pageId
             )));
 
         return {

package/src/notifications/api/notificationsApiFactory.js

@@ -3,9 +3,41 @@
  */
 'use strict';
 
-const { infoToProjection } = require('graphql-mongodb-projection');
 const apiAuthorizer = require('../../graphApi/apiAuthorizer');
 
+/**
+ *
+ * @param {*} info
+ * @returns {object}
+ */
+
+function getFields (info) {
+    if (info.fieldNodes) {
+        const fieldNodes = info.fieldNodes.filter((k) => k.kind === 'Field');
+
+        if (fieldNodes.length !== 1) {
+            return {};
+        }
+
+        return getFields(fieldNodes[0]);
+    }
+
+    const nodes = info.selectionSet ? info.selectionSet.selections : info.fieldNodes;
+
+    if (!info.selectionSet) {
+        return true;
+    }
+
+    return nodes.reduce((o, fieldInfo) => {
+        if (fieldInfo.kind !== 'Field' || !fieldInfo.name || !fieldInfo.name.value) {
+            return o;
+        }
+        return Object.assign(o, {
+            [fieldInfo.name.value]: getFields(fieldInfo)
+        });
+    }, {});
+}
+
 function notificationsApiFactory (storage, notifications, acl, options = {}) {
     return {
         async campaigns (args, ctx) {
@@ -87,9 +119,8 @@ function notificationsApiFactory (storage, notifications, acl, options = {}) {
                 };
             }
 
-            const data = await storage.getUnsuccessfulSubscribersByCampaign(
-                campaignId, sentWithoutReaction, pageId
-            );
+            const data = await storage
+                .getUnsuccessfulSubscribersByCampaign(campaignId, sentWithoutReaction, pageId);
 
             return {
                 data,
@@ -115,7 +146,7 @@ function notificationsApiFactory (storage, notifications, acl, options = {}) {
                 return null;
             }
 
-            const fields = infoToProjection(info);
+            const fields = getFields(info);
 
             const {
                 include,
@@ -132,7 +163,15 @@ function notificationsApiFactory (storage, notifications, acl, options = {}) {
             }
 
             if (fields.data) {
-                const res = storage.getSubscribtions(include, exclude, limit, pageId, lastKey);
+                const res = await storage
+                    .getSubscribtions(include, exclude, limit, pageId, lastKey);
+
+                if (fields.data.meta && typeof options.preprocessSubscriptions === 'function') {
+                    res.data = await Promise.resolve(
+                        options.preprocessSubscriptions(res.data, pageId)
+                    );
+                }
+
                 return Object.assign(res, { count });
             }
 
@@ -159,8 +198,12 @@ function notificationsApiFactory (storage, notifications, acl, options = {}) {
                 );
             }
 
-            for (const senderId of senderIds) {
-                await storage.subscribe(`${senderId}`, pageId, tag);
+            // make it little bit faster
+            while (senderIds.length > 0) {
+                await Promise.all(
+                    senderIds.splice(0, 5)
+                        .map((senderId) => storage.subscribe(`${senderId}`, pageId, tag))
+                );
             }
 
             return true;

package/src/resolvers/media.js

@@ -4,9 +4,14 @@
 'use strict';
 
 const Router = require('../Router');
+const getCondition = require('../utils/getCondition');
 const { stateData, cachedTranslatedCompilator } = require('./utils');
 
-function media (params, { isLastIndex }) {
+function media (
+    params,
+    // @ts-ignore
+    { isLastIndex } = {}
+) {
     const { type, url } = params;
 
     const urlString = url || '';
@@ -19,7 +24,13 @@ function media (params, { isLastIndex }) {
         throw new Error(`Unsupported media type: ${type}`);
     }
 
+    const condition = getCondition(params, 'Media condition');
+
     return (req, res) => {
+        if (condition && !condition(req, res)) {
+            return ret;
+        }
+
         const data = stateData(req, res);
         const sendUrl = urlTemplate(data);
 

package/src/resolvers/message.js

@@ -2,10 +2,40 @@
  * @author David Menger
  */
 'use strict';
-
+// eslint-disable-next-line no-unused-vars
+const Responder = require('../Responder');
+// eslint-disable-next-line no-unused-vars
+const Request = require('../Request');
 const Router = require('../Router');
 const getCondition = require('../utils/getCondition');
-const { cachedTranslatedCompilator, stateData } = require('./utils');
+const {
+    stateData, getLanguageText, getLanguageTextObjects, randomizedCompiler
+} = require('./utils');
+const {
+    FEATURE_SSML, FEATURE_TEXT, FEATURE_VOICE
+} = require('../features');
+
+/**
+ * Returns voice control props from params
+ *
+ * @param {any} params
+ * @param {string} lang
+ * @returns {null | import('../Responder').VoiceControl}
+ */
+function getVoiceControl (params, lang = null) {
+    const voiceControl = {};
+
+    const voiceControlProps = ['speed', 'pitch', 'volume', 'voice', 'style', 'language'];
+
+    voiceControlProps.forEach((prop) => {
+        if (params[prop]) {
+            voiceControl[prop] = getLanguageText(params[prop], lang);
+        }
+    });
+
+    // if voiceControl is empty, return null
+    return Object.keys(voiceControl).length > 0 ? voiceControl : null;
+}
 
 function parseReplies (replies, linksMap, allowForbiddenSnippetWords) {
     return replies.map((reply) => {
@@ -45,7 +75,7 @@ function parseReplies (replies, linksMap, allowForbiddenSnippetWords) {
             action,
             condition,
             title: reply.title
-                ? cachedTranslatedCompilator(reply.title)
+                ? randomizedCompiler(reply.title)
                 : null,
             data: {}
         };
@@ -70,43 +100,108 @@ function parseReplies (replies, linksMap, allowForbiddenSnippetWords) {
     });
 }
 
+/**
+ * @param {import('./utils').Translations} text
+ * @param {string[]} features
+ * @param {string} lang
+ * @returns {{translations: import('./utils').TextObject[],ssmlAlternatives:string[] | null}}
+ */
+function findSupportedMessages (text, features, lang = null) {
+    let translations = getLanguageTextObjects(text, lang);
+
+    const useSSML = features.includes(FEATURE_SSML);
+    const useText = features.includes(FEATURE_TEXT);
+    const useVoice = features.includes(FEATURE_VOICE);
+
+    // filter out SSML alternatives - they will be used in voice control
+    let ssmlAlternatives = translations.filter((t) => t.p === 's').map((t) => t.t);
+    if (ssmlAlternatives.length === 0 || !useSSML) {
+        ssmlAlternatives = null;
+    }
+
+    translations = translations.filter((t) => t.p !== 's');
+
+    // find supported text alternatives
+    translations = translations.filter((translation) => {
+        // always use text+voice
+        if (!translation.p) {
+            return true;
+        }
+
+        // text only
+        if (useText && translation.p === 't') {
+            return true;
+        }
+
+        // voice (& SSML) only
+        if (useVoice && translation.p === 'v') {
+            return true;
+        }
+
+        return false;
+    });
+
+    return {
+        translations,
+        ssmlAlternatives
+    };
+}
+
 function message (params, {
+    // @ts-ignore
     isLastIndex, isLastMessage, linksMap, allowForbiddenSnippetWords
-}) {
+} = {}) {
+
     if (typeof params.text !== 'string' && !Array.isArray(params.text)) {
         throw new Error('Message should be a text!');
     }
 
-    const textTemplate = cachedTranslatedCompilator(params.text);
-
+    // parse quick replies
     let quickReplies = null;
-
     if (params.replies && !Array.isArray(params.replies)) {
         throw new Error('Replies should be an array');
     } else if (params.replies && params.replies.length > 0) {
         quickReplies = parseReplies(params.replies, linksMap, allowForbiddenSnippetWords);
     }
 
+    // compile condition
     const condition = getCondition(params, 'Message condition', allowForbiddenSnippetWords);
 
     const ret = isLastIndex ? Router.END : Router.CONTINUE;
 
+    /**
+     * @param {Request} req
+     * @param {Responder} res
+     */
     return (req, res) => {
-        if (condition !== null) {
-            if (!condition(req, res)) {
-                return ret;
-            }
+        if (condition && !condition(req, res)) {
+            return ret;
         }
-
         const data = stateData(req, res);
+
+        // filter supported messages
+        /** @type {{translations:import('./utils').TextObject[],ssmlAlternatives:string[]}} */
+        const supportedText = findSupportedMessages(
+            params.text,
+            req.features,
+            data.lang
+        );
+
+        // find random alternative
+        const textTemplate = randomizedCompiler([{
+            l: data.lang,
+            t: supportedText.translations.map((x) => x.t)
+        }]);
+
         const text = textTemplate(data)
             .trim();
 
+        let sendReplies;
         if (quickReplies) {
             const okQuickReplies = quickReplies
                 .filter((reply) => reply.condition(req, res));
 
-            const sendReplies = okQuickReplies
+            sendReplies = okQuickReplies
                 .filter((reply) => reply.title
                     || reply.isLocation
                     || reply.isEmail
@@ -123,8 +218,6 @@ function message (params, {
                     return rep;
                 });
 
-            res.text(text, sendReplies);
-
             okQuickReplies
                 .filter((reply) => !reply.title && reply.match)
                 .forEach(({
@@ -134,10 +227,27 @@ function message (params, {
                 });
         } else {
             // replies on last index will be present, so the addQuickReply will be working
-            const sendReplies = isLastMessage ? [] : undefined;
-            res.text(text, sendReplies);
+            sendReplies = isLastMessage ? [] : undefined;
         }
 
+        // generate voice control
+        let voiceControl = getVoiceControl(params, data.lang);
+        if (supportedText.ssmlAlternatives) {
+            // find SSML alternative
+            const ssmlAlternativeTemplate = randomizedCompiler([{
+                l: data.lang,
+                t: supportedText.ssmlAlternatives
+            }]);
+
+            voiceControl = {
+                ...voiceControl,
+                ssml: ssmlAlternativeTemplate(data)
+                    .trim()
+            };
+        }
+
+        res.text(text, sendReplies, voiceControl);
+
         return ret;
     };
 }

package/src/resolvers/utils.js

@@ -19,6 +19,28 @@ const WEBVIEW_FULL = 'full';
 const WEBVIEW_TALL = 'tall';
 const WEBVIEW_COMPACT = 'compact';
 
+/**
+ * @typedef {Translation[] | Translation | string[] | string} Translations
+ */
+
+/**
+ * @typedef {object} TextObject
+ * @prop {string} t - text
+ * @prop {string} l - lang
+ * @prop {string|null} p - purpose
+ */
+
+/**
+ * @typedef Translation
+ * @property {string|string[]} t - text alternatives
+ * @property {string | null} l - language
+ * @property {string|string[]} [p] - purposes
+ * null = default + voice
+ * t = text
+ * v = voice
+ * s = ssml
+ */
+
 function isArrayOfObjects (translations) {
     return Array.isArray(translations)
         && typeof translations[0] === 'object'
@@ -36,18 +58,20 @@ function isTextObjectEmpty (text) {
 }
 
 /**
- *
- * @param {{t:string,l:string}[]|string} translations
+ * @param {Translations} translations
  * @param {string} [lang]
  * @returns {null|string}
  */
 function getLanguageText (translations, lang = null) {
     let foundText;
+
     if (isArrayOfObjects(translations)) {
         if (lang) {
+            // @ts-ignore
             foundText = translations.find((t) => t.l === lang);
         }
         if (isTextObjectEmpty(foundText)) {
+            // @ts-ignore
             foundText = translations.find((t) => !isTextObjectEmpty(t));
         }
         foundText = foundText ? foundText.t : null;
@@ -63,6 +87,58 @@ function getLanguageText (translations, lang = null) {
     }
     return foundText || '';
 }
+/**
+ *
+ * @param {Translations} translations
+ * @param {string} [lang]
+ * @returns {TextObject[]}
+ */
+function getLanguageTextObjects (translations, lang = null) {
+    /** @type {{t:string|string[],l?:string,p?:string|string[]}[]} */
+    let foundTexts;
+
+    if (!Array.isArray(translations) || typeof translations[0] === 'string') {
+        // @ts-ignore
+        foundTexts = [{ t: translations, l: lang }];
+    } else { // is array of objects
+        foundTexts = translations
+            // @ts-ignore
+            .filter(({ l = null, ...to }) => l === lang && !isTextObjectEmpty(to));
+
+        if (foundTexts.length === 0) {
+            const { l: firstNonEmptyLang = null } = translations
+                // @ts-ignore
+                .find((to) => !isTextObjectEmpty(to)) || {};
+
+            foundTexts = translations
+                // @ts-ignore
+                .filter(({ l = null, ...to }) => l === firstNonEmptyLang && !isTextObjectEmpty(to));
+        }
+    }
+
+    return foundTexts
+        .reduce((a, to) => {
+            if (Array.isArray(to.t)) {
+                const purposes = Array.isArray(to.p)
+                    ? to.p
+                    : [to.p];
+                a.push(
+                    ...to.t.map((t, i) => ({
+                        ...to, t, p: purposes[i] || null
+                    }))
+                );
+            } else {
+                a.push(to);
+            }
+            return a;
+        }, [])
+        .filter((to) => !!to.t)
+        .map(({
+            t, l = null, p = null, ...rest
+        }) => ({
+            t, l, p, ...rest
+        }));
+}
 
 function randomizedCompiler (text, lang) {
     const texts = getLanguageText(text, lang);
@@ -100,6 +176,13 @@ function randomizedCompiler (text, lang) {
     };
 }
 
+/**
+ * l - language
+ * t - alternatives
+ *
+ * @param {{l:string,t:string[]}[] | string} text
+ * @returns {(state:any)=>string}
+ */
 function cachedTranslatedCompilator (text) {
     const cache = new Map();
 
@@ -119,18 +202,21 @@ function getText (text, state) {
     return renderer(state);
 }
 
+// eslint-disable-next-line no-unused-vars
+const DEFAULT_LINK_TRANSLATOR = (senderId, defaultText, urlText, isExtUrl, reqState) => urlText;
+
 function processButtons (
     buttons,
     state,
     elem,
     linksMap,
     senderId,
-    // eslint-disable-next-line no-unused-vars
-    linksTranslator = (sndr, defaultText, urlText, isExtUrl, reqState) => urlText,
+    linksTranslator,
     allowForbiddenSnippetWords,
     req,
     res
 ) {
+    const translateLinks = linksTranslator || DEFAULT_LINK_TRANSLATOR;
 
     buttons.forEach(({
         title: btnTitle,
@@ -168,7 +254,7 @@ function processButtons (
             case TYPE_URL_WITH_EXT: {
                 const hasExtention = type === TYPE_URL_WITH_EXT;
                 let urlText = getText(url, state);
-                urlText = linksTranslator(senderId, defaultText, urlText, isExtUrl, state);
+                urlText = translateLinks(senderId, defaultText, urlText, isExtUrl, state);
                 elem.urlButton(btnTitleText, urlText, hasExtention, webviewHeight);
                 break;
             }
@@ -194,7 +280,9 @@ function processButtons (
 
 module.exports = {
     getLanguageText,
+    getLanguageTextObjects,
     cachedTranslatedCompilator,
+    randomizedCompiler,
     getText,
     stateData,
 

package/src/tools/MemoryBotConfigStorage.js

@@ -22,7 +22,7 @@ class MemoryBotConfigStorage {
      * @param {Function|string[]} [acl] - acl configuration
      * @returns {{updateBot:Function}}
      */
-    api (onUpdate = () => Promise.resolve(), acl) {
+    api (onUpdate = () => Promise.resolve(), acl = []) {
         const storage = this;
         return {
             async updateBot (args, ctx) {

package/src/utils/customCondition.js

@@ -42,7 +42,7 @@ const isSimpleWord = (string) => {
 const isStringNumber = (string) => {
     if (typeof string !== 'string') return false;
     if (string.length === 0) return false;
-    return !!new RegExp(/^([0-9]*[, ]{0,1})*[., ]{0,1}[0-9]*$/)
+    return !!/^([0-9]*[, ]{0,1})*[., ]{0,1}[0-9]*$/
         .test((string).replace(/\s+/g, ''));
 };
 
@@ -55,7 +55,7 @@ const stringToNumber = (string) => {
     if (typeof string !== 'string') return string;
     if (!isStringNumber(string)) throw new Error('String not a number');
     let trimmed;
-    if (new RegExp(/^[^,.]+,[^,.]+$/).test(string)) {
+    if (/^[^,.]+,[^,.]+$/.test(string)) {
         trimmed = string.replace(',', '.');
     } else {
         trimmed = string.replace(/(\s|,)+/g, '').replace(',', '.');

package/src/utils/getUpdate.js

@@ -88,8 +88,10 @@ function toArray (previousValue) {
 const ENTITY_HBS_REGEXP = /^\s*\{\{\[?@([^@[\]{}\s]+)(\])?\}\}\s*$/;
 const VARIABLE_HBS_REGEXP = /^\s*\{\{\[?([^@[\]{}\s]+)\]?\}\}\s*$/;
 
-function getSetState (setState = {}, req, res = null, useState = null) {
-
+function getSetState (setState, req, res = null, useState = null) {
+    if (!setState) {
+        return {};
+    }
     const keys = Object.keys(setState)
         .filter((k) => k !== '_');
 

package/src/utils/quickReplies.js

@@ -32,7 +32,12 @@ const { checkSetState } = require('./stateVariables');
  * @returns {ExpectedKeyword}
  */
 function makeExpectedKeyword (
-    action, title, matcher = null, payloadData = {}, setState = null, aiTitle = null
+    action,
+    title,
+    matcher = null,
+    payloadData = {},
+    setState = null,
+    aiTitle = null
 ) {
     let match = null;
 
@@ -226,7 +231,12 @@ function makeQuickReplies (replies, path = '', translate = (w) => w, quickReplyC
             const translatedTitle = translate(title);
             const translatedAiTitle = typeof aiTitle === 'string' ? translate(aiTitle) : aiTitle;
             const expect = makeExpectedKeyword(
-                absoluteAction, translatedTitle, match, data, setState, translatedAiTitle
+                absoluteAction,
+                translatedTitle,
+                match,
+                data,
+                setState,
+                translatedAiTitle
             );
             expectedKeywords.push(expect);