wingbot 3.32.0 → 3.33.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.32.0",
+  "version": "3.33.1",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "scripts": {

package/src/Ai.js

@@ -229,7 +229,7 @@ class Ai {
      *
      * @param {string} path
      * @param {IntentRule|IntentRule[]} intents
-     * @param {string} [title] - disambiguation title
+     * @param {string|Function} [title] - disambiguation title
      * @param {object} [meta] - metadata for multibot environments
      * @param {object} [meta.targetAppId] - target application id
      * @param {object} [meta.targetAction] - target action
@@ -276,7 +276,7 @@ class Ai {
      *
      * @param {string} path
      * @param {IntentRule|IntentRule[]} intents
-     * @param {string} [title] - disambiguation title
+     * @param {string|Function} [title] - disambiguation title
      * @returns {object} - the middleware
      * @memberOf Ai
      * @example

package/src/BuildRouter.js

@@ -17,6 +17,67 @@ const { shouldExecuteResolver } = require('./resolvers/resolverTags');
 
 const MESSAGE_RESOLVER_NAME = 'botbuild.message';
 
+/** @typedef {import('./Router').Middleware} Middleware */
+
+/**
+ * @typedef {object} Resolver
+ * @prop {string} type
+ * @prop {object} params
+ * @prop {string} [params.staticBlockId]
+ * @prop {string} [tag]
+ */
+
+/** @typedef {import('./resolvers/bounce').BounceAllow} BounceAllow */
+/** @typedef {import('./resolvers/bounce').BounceReturn} BounceReturn */
+
+/**
+ * @typedef {object} Route
+ * @prop {number} id
+ * @prop {string|null} path
+ * @prop {Resolver[]} resolvers
+ * @prop {boolean} [isFallback]
+ * @prop {string[]} [aiTags]
+ * @prop {boolean} [isResponder]
+ * @prop {number} [respondsToRouteId]
+ * @prop {string|any[]} [aiTitle]
+ * @prop {boolean} [aiGlobal]
+ * @prop {BounceAllow} [bounceAllowedTo]
+ * @prop {BounceReturn} [bounceReturn]
+ * @prop {boolean} [isEntryPoint]
+ */
+
+/**
+ * @typedef {object} RouteTransformation
+ * @prop {string} [expectedPath]
+ *
+ * @typedef {RouteTransformation & Route} TransformedRoute
+ */
+
+/**
+ * @typedef {Map<string|number,string>} LinksMap
+ */
+
+/** @type {TransformedRoute} */
+const DUMMY_ROUTE = { id: 0, path: null, resolvers: [] };
+
+/**
+ * @typedef {object} Block
+ * @prop {string} staticBlockId
+ * @prop {Route[]} routes
+ * @prop {boolean} [isRoot]
+ * @prop {boolean} [disabled]
+ * @prop {string} [blockName]
+ * @prop {string} [blockType]
+ */
+
+/**
+ * @typedef {object} BotConfig
+ * @prop {string} botId - the ID of bot
+ * @prop {string} snapshot - snapshot stage of bot
+ * @prop {string|Promise<string>} token - authorization token for bot
+ * @prop {string} [url] - specify alternative configuration resource
+ */
+
 /**
  * @typedef {object} ConfigStorage
  * @prop {{():Promise}} invalidateConfig
@@ -25,6 +86,61 @@ const MESSAGE_RESOLVER_NAME = 'botbuild.message';
  * @prop {{():Promise<Object>}} getConfig
  */
 
+/**
+ * @typedef {object} RouteConfig
+ * @prop {string} path
+ * @prop {boolean} enabled
+ * @prop {object} configuration
+ */
+
+/**
+ * @callback LinkTranslator
+ * @param {string} senderId
+ * @param {string} textLabel
+ * @param {string} urlText
+ * @param {boolean} [isExtUrl]
+ * @param {object} [state]
+ * @returns {string}
+ */
+
+/**
+ * @typedef {object} BotContext
+ * @prop {LinkTranslator} [linksTranslator] - function, that translates links globally
+ * @prop {ConfigStorage} [configStorage] - function, that translates links globally
+ * @prop {boolean} [allowForbiddenSnippetWords] - disable security rule
+ * @prop {RouteConfig[]} [routeConfigs] - list of disabled routes
+ * @prop {object} [configuration] - context data
+ * @prop {LinksMap} [linksMap]
+ * @prop {boolean} [isLastIndex]
+ * @prop {boolean} [isLastMessage]
+ * @prop {BuildRouter} [router]
+ * @prop {string} [path]
+ * @prop {boolean} [isFallback]
+ * @prop {string} [expectedPath]
+ * @prop {boolean} [isResponder]
+ * @prop {string|number} [routeId]
+ * @prop {string} [blockName]
+ * @prop {string} [blockType]
+ * @prop {boolean} [isRoot]
+ * @prop {string} [staticBlockId]
+ * @prop {Block[]} [blocks]
+ * @prop {object} [BuildRouter]
+ */
+
+function deepFreeze (object) {
+    const propNames = Object.getOwnPropertyNames(object);
+
+    for (const name of propNames) {
+        const value = object[name];
+
+        if (value && typeof value === 'object') {
+            deepFreeze(value);
+        }
+    }
+
+    return Object.freeze(object);
+}
+
 /**
  * Build bot from Wingbot configuration file or snapshot url
  *
@@ -36,16 +152,14 @@ class BuildRouter extends Router {
      * Create new router from configuration
      *
      * @constructor
-     * @param {object} block
-     * @param {string} [block.botId] - the ID of bot
-     * @param {string} [block.snapshot] - snapshot stage of bot
-     * @param {string|Promise<string>} [block.token] - authorization token for bot
-     * @param {string} [block.url] - specify alternative configuration resource
+     * @param {BotConfig|Block} block
      * @param {Plugins} plugins - custom code blocks resource
      * @param {object} context - the building context
      * @param {object} [context.linksTranslator] - function, that translates links globally
      * @param {ConfigStorage} [context.configStorage] - function, that translates links globally
      * @param {boolean} [context.allowForbiddenSnippetWords] - disable security rule
+     * @param {RouteConfig[]} [context.routeConfigs] - list of disabled routes
+     * @param {object} [context.configuration]
      * @param {fetch} [fetchFn] - override a request function
      * @example
      *
@@ -76,8 +190,10 @@ class BuildRouter extends Router {
 
         this._plugins = plugins;
 
+        /** @type {BotContext} */
         this._context = context;
 
+        /** @type {LinksMap} */
         this._linksMap = new Map();
 
         this._loadBotUrl = null;
@@ -94,7 +210,7 @@ class BuildRouter extends Router {
 
         this.resources = defaultResourceMap();
 
-        this._loadBotAuthorization = block.token || null;
+        this._loadBotAuthorization = 'token' in block ? block.token : null;
 
         this._configStorage = context.configStorage;
 
@@ -112,7 +228,7 @@ class BuildRouter extends Router {
         this._snapshot = null;
         this._botId = null;
 
-        if (typeof block.routes === 'object') {
+        if ('routes' in block) {
             this._buildBot(block);
         } else if (typeof block.url === 'string') {
             this._loadBotUrl = block.url;
@@ -315,6 +431,12 @@ class BuildRouter extends Router {
         }
     }
 
+    /**
+     *
+     * @param {Block} block
+     * @param {number} setConfigTimestamp
+     * @param {string} lastmod
+     */
     _buildBot (block, setConfigTimestamp = Number.MAX_SAFE_INTEGER, lastmod = '-') {
         try {
             if (setConfigTimestamp !== Number.MAX_SAFE_INTEGER) {
@@ -390,7 +512,13 @@ class BuildRouter extends Router {
         });
     }
 
+    /**
+     *
+     * @param {Block} block
+     * @returns {LinksMap}
+     */
     _createLinksMap (block) {
+        /** @type {LinksMap} */
         const linksMap = new Map();
 
         block.routes
@@ -402,35 +530,140 @@ class BuildRouter extends Router {
         if (prevLinksMap) {
             for (const [from, to] of prevLinksMap.entries()) {
                 if (!linksMap.has(from)) {
-
-                    (path.posix || path).join('..', to);
-
-                    linksMap.set(from, (path.posix || path).join('..', to));
+                    linksMap.set(from, this._joinPaths('..', to));
                 }
             }
         }
 
         block.routes.forEach((route) => {
-            let resolver;
-            for (resolver of route.resolvers) {
-                if (resolver.type !== 'botbuild.include') {
-                    continue;
-                }
-                this._findEntryPointsInResolver(linksMap, resolver, route, this._context);
+            const enabledNestedBlock = this._getBlockById(this._getIncludedBlockId(route));
+            if (!enabledNestedBlock) {
+                return;
+            }
+            const routeConfig = this._getRouteConfig(route);
+            if (this._enabledByRouteConfig(routeConfig)) {
+                this._findEntryPointsInResolver(linksMap, enabledNestedBlock, route);
             }
         });
 
         return linksMap;
     }
 
-    _findEntryPointsInResolver (linksMap, resolver, route, context) {
-        const includedBlock = (context.blocks || [])
-            .find((b) => b.staticBlockId === resolver.params.staticBlockId);
+    /**
+     *
+     * @param {RouteConfig} routeConfig
+     */
+    _enabledByRouteConfig (routeConfig) {
+        return !this._context.routeConfigs || (routeConfig && routeConfig.enabled);
+    }
 
-        if (!includedBlock) {
-            return;
+    _joinPaths (...args) {
+        return (path.posix || path).join(...args);
+    }
+
+    _normalizeConfigPath (routePath, ctxPath = null) {
+        const joined = ctxPath
+            ? this._joinPaths(ctxPath, routePath)
+            : routePath;
+
+        return joined
+            .replace(/^\/?|(_responder)?\/?$/g, '/');
+    }
+
+    /**
+     *
+     * @param {Route} route
+     * @returns {string|null}
+     */
+    _getIncludedBlockId (route) {
+        const includeResolver = route.resolvers.find((r) => r.type === 'botbuild.include');
+
+        return includeResolver
+            ? includeResolver.params.staticBlockId
+            : null;
+    }
+
+    /**
+     *
+     * @param {string} staticBlockId
+     * @returns {Block|null}
+     */
+    _getBlockById (staticBlockId) {
+        if (!staticBlockId) {
+            return null;
+        }
+        const nestedBlock = (this._context.blocks || [])
+            .find((b) => b.staticBlockId === staticBlockId);
+
+        if (!nestedBlock || nestedBlock.disabled) {
+            return null;
+        }
+        return nestedBlock;
+    }
+
+    /**
+     *
+     * @param {TransformedRoute} route
+     * @returns {RouteConfig}
+     */
+    _getRouteConfig (route) {
+        const { path: ctxPath, routeConfigs } = this._context;
+        if (!routeConfigs || !route.path || route.isFallback) {
+            return null;
+        }
+
+        let rPath;
+        if (!route.isResponder) {
+            rPath = route.path;
+        } else if (route.expectedPath) {
+            rPath = route.expectedPath;
+        } else if (this._linksMap.has(route.respondsToRouteId)) {
+            rPath = this._linksMap.get(route.respondsToRouteId);
+        } else {
+            throw new Error('Illegal state');
         }
 
+        const routePath = this._normalizeConfigPath(rPath, ctxPath);
+        return routeConfigs.find((config) => {
+            const configPath = this._normalizeConfigPath(config.path);
+
+            return configPath === routePath;
+        });
+    }
+
+    /**
+     *
+     * @param {string} routePath
+     * @returns {object}
+     */
+    getConfiguration (routePath) {
+        const { path: ctxPath, routeConfigs, configuration = {} } = this._context;
+        if (!routeConfigs || !routePath) {
+            return deepFreeze(configuration);
+        }
+        const normalized = this._normalizeConfigPath(routePath, ctxPath);
+
+        const configs = routeConfigs
+            .filter((config) => {
+                const configPath = this._normalizeConfigPath(config.path);
+                return normalized.startsWith(configPath);
+            })
+            .sort((a, z) => a.path.length - z.path.length);
+
+        return deepFreeze(configs.reduce((cfg, config) => ({
+            ...cfg,
+            ...config.configuration
+        }), configuration));
+    }
+
+    /**
+     *
+     * @param {LinksMap} linksMap
+     * @param {Block} includedBlock
+     * @param {TransformedRoute} route
+     * @returns {void}
+     */
+    _findEntryPointsInResolver (linksMap, includedBlock, route) {
         let basePath = `${route.path}/`;
 
         if (route.isFallback) {
@@ -438,14 +671,20 @@ class BuildRouter extends Router {
         }
 
         includedBlock.routes.forEach((blockRoute) => {
-            if (!blockRoute.isEntryPoint || blockRoute.isRoot) {
+            if (!blockRoute.isEntryPoint) {
                 return;
             }
 
-            linksMap.set(`${blockRoute.id}`, `${basePath}${blockRoute.path}`);
+            linksMap.set(blockRoute.id, `${basePath}${blockRoute.path}`);
         });
     }
 
+    /**
+     *
+     * @param {TransformedRoute} route
+     * @param {boolean} nextRouteIsSameResponder
+     * @returns {Middleware[]}
+     */
     _buildRouteHead (route, nextRouteIsSameResponder) {
         const resolvers = [];
 
@@ -453,10 +692,10 @@ class BuildRouter extends Router {
             let aiResolver = null;
 
             if (route.aiTags && route.aiTags.length) {
-                let { aiTitle = null } = route;
+                let aiTitle = null;
 
-                if (aiTitle) {
-                    aiTitle = cachedTranslatedCompilator(aiTitle);
+                if (route.aiTitle) {
+                    aiTitle = cachedTranslatedCompilator(route.aiTitle);
                 }
 
                 if (route.aiGlobal) {
@@ -488,8 +727,25 @@ class BuildRouter extends Router {
         return resolvers;
     }
 
+    /**
+     *
+     * @param {TransformedRoute[]} routes
+     */
     _buildRoutes (routes) {
         routes.forEach((route, i) => {
+            const routeConfig = this._getRouteConfig(route);
+
+            if (routeConfig && !routeConfig.enabled) {
+                return;
+            }
+
+            const includedBlockId = this._getIncludedBlockId(route);
+            const nestedBlock = this._getBlockById(includedBlockId);
+
+            if (includedBlockId && (!nestedBlock || !this._enabledByRouteConfig(routeConfig))) {
+                return;
+            }
+
             const nextRoute = routes.length > (i + 1)
                 ? routes[i + 1]
                 : null;
@@ -523,6 +779,11 @@ class BuildRouter extends Router {
         });
     }
 
+    /**
+     *
+     * @param {Resolver[]} resolvers
+     * @returns {number}
+     */
     _lastMessageIndex (resolvers) {
         for (let i = resolvers.length - 1; i >= 0; i--) {
             if (resolvers[i].type === MESSAGE_RESOLVER_NAME) {
@@ -532,15 +793,30 @@ class BuildRouter extends Router {
         return -1;
     }
 
-    buildResolvers (resolvers, route = {}, buildInfo = {}) {
+    /**
+     *
+     * @param {Resolver[]} resolvers
+     * @param {TransformedRoute} route
+     * @param {*} buildInfo
+     * @returns {Middleware[]}
+     */
+    buildResolvers (resolvers, route = DUMMY_ROUTE, buildInfo = {}) {
         const {
             path: ctxPath, isFallback, isResponder, expectedPath, id
         } = route;
 
+        const routeConfig = this._getRouteConfig(route);
+        const routeConfigData = routeConfig && routeConfig.configuration;
+
         const lastMessageIndex = this._lastMessageIndex(resolvers);
         const lastIndex = resolvers.length - 1;
 
         return resolvers.map((resolver, i) => {
+            const configuration = deepFreeze({
+                ...this._context.configuration,
+                ...routeConfigData
+            });
+
             const context = {
                 ...this._context,
                 isLastIndex: lastIndex === i && !buildInfo.expectedToAddResolver,
@@ -551,13 +827,25 @@ class BuildRouter extends Router {
                 isFallback,
                 isResponder,
                 expectedPath,
-                routeId: id
+                routeId: id,
+                configuration
             };
 
-            return this._resolverFactory(resolver, context, buildInfo);
+            const resFn = this._resolverFactory(resolver, context, buildInfo);
+
+            // @ts-ignore
+            resFn.configuration = configuration;
+            return resFn;
         });
     }
 
+    /**
+     *
+     * @param {Resolver} resolver
+     * @param {BotContext} context
+     * @param {*} buildInfo
+     * @returns {Middleware}
+     */
     _resolverFactory (resolver, context, buildInfo) {
         const { type } = resolver;
 
@@ -618,9 +906,9 @@ class BuildRouter extends Router {
 }
 
 /**
- * @param {object[]} blocks - blocks list
+ * @param {Block[]} blocks - blocks list
  * @param {Plugins} [plugins]
- * @param {object} [context]
+ * @param {BotContext} [context]
  */
 BuildRouter.fromData = function fromData (blocks, plugins = new Plugins(), context = {}) {
 

package/src/ConversationTester.js

@@ -603,19 +603,13 @@ class ConversationTester {
             } else {
                 const quickReplyRequired = action.match(/^>/);
                 const cleanAction = action.replace(/^>/, '');
-                let found;
 
                 // action in quick reply
                 if (action.match(/^>\//)) {
                     await t.quickReply(cleanAction);
-                    found = true;
+                } else if (quickReplyRequired) {
+                    await t.quickReplyText(cleanAction);
                 } else {
-                    found = await t.quickReplyText(cleanAction);
-                }
-
-                if (!found && quickReplyRequired) {
-                    throw new Error(`Quick reply "${action.replace(/^>/, '')}" was required, but has not been found`);
-                } else if (!found) {
                     await t.text(action);
                 }
             }

package/src/Processor.js

@@ -14,6 +14,7 @@ const { mergeState } = require('./utils/stateVariables');
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').Intent} Intent */
 /** @typedef {import('./ReducerWrapper')} ReducerWrapper */
 /** @typedef {import('./Router')} Router */
+/** @typedef {import('./BuildRouter')} BuildRouter */
 
 /**
  * @typedef {object} AutoTypingConfig
@@ -121,7 +122,7 @@ class Processor extends EventEmitter {
     /**
      * Creates an instance of Processor
      *
-     * @param {ReducerWrapper|Router} reducer
+     * @param {ReducerWrapper|Router|BuildRouter} reducer
      * @param {ProcessorOptions} [options] - processor options
      *
      * @memberOf Processor
@@ -548,6 +549,11 @@ class Processor extends EventEmitter {
                 res.setBookmark(aByAi);
             }
 
+            if ('getConfiguration' in this.reducer) {
+                const configuration = this.reducer.getConfiguration(state._lastAction);
+                req.configuration = Object.freeze(configuration);
+            }
+
             // process setState
             const setState = req.getSetState(req.AI_SETSTATE.EXCLUDE_WITH_SET_ENTITIES);
             await Ai.ai.processSetStateEntities(req, setState);

package/src/Request.js

@@ -264,6 +264,9 @@ class Request {
          * @constant {string} FEATURE_TRACKING channel supports tracking protocol
          */
         this.FEATURE_TRACKING = FEATURE_TRACKING;
+
+        /** @type {object} */
+        this.configuration = Object.freeze({});
     }
 
     get data () {

package/src/Router.js

@@ -140,7 +140,12 @@ class Router extends ReducerWrapper {
 
                 const reducersArray = reducer.map((re) => {
                     const {
-                        resolverPath, reduce, isReducer, globalIntents: gis, globalIntentsMeta = {}
+                        resolverPath,
+                        reduce,
+                        isReducer,
+                        globalIntents: gis,
+                        globalIntentsMeta,
+                        configuration
                     } = this._createReducer(
                         re,
                         pathContext.path
@@ -149,16 +154,19 @@ class Router extends ReducerWrapper {
                     Object.assign(pathContext, { path: resolverPath });
                     Object.assign(pathContext.globalIntentsMeta, globalIntentsMeta);
                     isAnyReducer = isAnyReducer || isReducer;
-                    return { reduce, isReducer };
+                    return { reduce, isReducer, configuration };
                 });
 
                 return {
-                    reducers: reducersArray, isReducer: isAnyReducer, isOr: true, globalIntents
+                    reducers: reducersArray,
+                    isReducer: isAnyReducer,
+                    isOr: true,
+                    globalIntents
                 };
             }
 
             const {
-                resolverPath, reduce, isReducer, globalIntents, globalIntentsMeta = {}
+                resolverPath, reduce, isReducer, globalIntents, globalIntentsMeta, configuration
             } = this._createReducer(
                 reducer,
                 pathContext.path
@@ -167,7 +175,9 @@ class Router extends ReducerWrapper {
             Object.assign(pathContext, { path: resolverPath });
             Object.assign(pathContext.globalIntentsMeta, globalIntentsMeta);
 
-            return { reduce, isReducer, globalIntents };
+            return {
+                reduce, isReducer, globalIntents, configuration
+            };
         });
     }
 
@@ -178,7 +188,8 @@ class Router extends ReducerWrapper {
         const {
             globalIntents = new Map(),
             path,
-            globalIntentsMeta = {}
+            globalIntentsMeta = {},
+            configuration = null
         } = reducer;
 
         if (typeof reducer === 'string' || path) {
@@ -219,7 +230,7 @@ class Router extends ReducerWrapper {
         }
 
         return {
-            resolverPath, isReducer, reduce, globalIntents, globalIntentsMeta
+            resolverPath, isReducer, reduce, globalIntents, globalIntentsMeta, configuration
         };
     }
 
@@ -291,6 +302,9 @@ class Router extends ReducerWrapper {
 
             let pathContext = `${path === '/' ? '' : path}${route.path.replace(/\/\*/, '')}`;
             res.setPath(path, route.path);
+            if (reducer.configuration) {
+                req.configuration = reducer.configuration;
+            }
 
             let result;
 

package/src/Tester.js

@@ -452,7 +452,7 @@ class Tester {
     }
 
     /**
-     * Send quick reply if text exactly matches, otherwise returns false
+     * Send quick reply if text exactly matches, otherwise throws exception
      *
      * @param {string} text
      * @returns {Promise<boolean>}
@@ -460,22 +460,37 @@ class Tester {
      * @memberOf Tester
      */
     async quickReplyText (text) {
+        let found = '';
+        let but = 'has not been found';
 
         if (this.responses.length !== 0) {
-            const search = tokenize(text);
+            const normalize = (t) => `${t}`.toLocaleLowerCase().replace(/\s+/g, ' ').trim();
+            const normalizedText = normalize(text);
+            const search = tokenize(normalizedText);
             const last = this.responses[this.responses.length - 1];
             const quickReplys = asserts.getQuickReplies(last);
-            const res = quickReplys
+            let res = quickReplys
                 .filter(({ title = '', payload }) => title && payload && tokenize(title) === search);
 
-            if (res[0]) {
+            if (res.length > 1) {
+                res = res
+                    .filter(({ title = '' }) => normalize(title) === normalizedText);
+            }
+
+            if (res.length === 1) {
                 const { title, payload } = res[0];
                 await this.processMessage(Request.quickReplyText(this.senderId, title, payload));
                 return true;
             }
+
+            if (res.length > 1) {
+                but = 'found multiple occurences';
+            }
+
+            found = ` (found: ${quickReplys.map((q) => q.title).filter((q) => !!q).join(', ')})`;
         }
 
-        return false;
+        throw new Error(`Quick reply "${text}" was required, but ${but}.${found}`);
     }
 
     /**

package/src/notifications/Notifications.js

@@ -545,7 +545,7 @@ class Notifications extends EventEmitter {
             if (!campaign.hasEditableCondition) {
                 fn = customFn(campaign.condition, `Campaign "${campaign.name}" condition`);
             } else {
-                fn = customCondition(campaign.editableCondition, `Campaign "${campaign.name}" condition`);
+                fn = customCondition(campaign.editableCondition, req.configuration, `Campaign "${campaign.name}" condition`);
             }
 
             const fnRes = fn(req, res);

package/src/resolvers/bounce.js

@@ -22,12 +22,15 @@ const BOUNCE_RETURN = {
     IF_POSSIBLE: 'ifpos'
 };
 
+/** @typedef {import('../BuildRouter').Route} Route */
+
+/** @typedef {BOUNCE_RETURN} BounceReturn */
+/** @typedef {BOUNCE_ALLOW} BounceAllow */
+
 /**
  *
  *
- * @param {object} route
- * @param {BOUNCE_ALLOW} [route.bounceAllowedTo]
- * @param {BOUNCE_RETURN} [route.bounceReturn]
+ * @param {Route} route
  * @param {boolean} nextRouteIsSameResponder
  * @param {string} [referredRoutePath]
  * @returns {Function|null}

package/src/resolvers/button.js

@@ -11,19 +11,26 @@ const {
     processButtons
 } = require('./utils');
 
-function button (params, {
-    isLastIndex,
-    linksMap,
-    linksTranslator,
-    allowForbiddenSnippetWords
-}) {
+/** @typedef {import('../BuildRouter').BotContext} BotContext */
+/** @typedef {import('../Router').Resolver} Resolver */
+
+/**
+ *
+ * @param {object} params
+ * @param {BotContext} context
+ * @returns {Resolver}
+ */
+function button (params, context) {
+    const {
+        isLastIndex
+    } = context;
     const {
         buttons = [],
         text = null
     } = params;
     const compiledText = cachedTranslatedCompilator(text);
 
-    const condition = getCondition(params, '', allowForbiddenSnippetWords);
+    const condition = getCondition(params, context, 'button');
 
     const ret = isLastIndex ? Router.END : Router.CONTINUE;
 
@@ -37,17 +44,15 @@ function button (params, {
             }
         }
 
-        const state = stateData(req, res);
+        const state = stateData(req, res, context.configuration);
         const tpl = res.button(compiledText(state));
 
         processButtons(
             buttons,
             state,
             tpl,
-            linksMap,
             req.senderId,
-            linksTranslator,
-            allowForbiddenSnippetWords,
+            context,
             req,
             res
         );

package/src/resolvers/carousel.js

@@ -17,12 +17,12 @@ const {
     TYPE_URL_WITH_EXT
 } = require('./utils');
 
-function carousel (params, {
-    isLastIndex,
-    linksMap,
-    linksTranslator = (a, b, c) => c,
-    allowForbiddenSnippetWords
-}) {
+function carousel (params, context) {
+    const {
+        isLastIndex,
+        linksMap,
+        linksTranslator = (a, b, c) => c
+    } = context;
     const {
         items = [],
         shareable = false,
@@ -36,7 +36,7 @@ function carousel (params, {
             return ret;
         }
 
-        const state = stateData(req, res);
+        const state = stateData(req, res, context.configuration);
         const isSquare = imageAspect === ASPECT_SQUARE;
         const tpl = res.genericTemplate(shareable, isSquare);
 
@@ -99,10 +99,8 @@ function carousel (params, {
                 buttons,
                 state,
                 elem,
-                linksMap,
                 senderId,
-                linksTranslator,
-                allowForbiddenSnippetWords,
+                context,
                 req,
                 res
             );

package/src/resolvers/media.js

@@ -7,11 +7,17 @@ const Router = require('../Router');
 const getCondition = require('../utils/getCondition');
 const { stateData, cachedTranslatedCompilator } = require('./utils');
 
-function media (
-    params,
-    // @ts-ignore
-    { isLastIndex } = {}
-) {
+/** @typedef {import('../BuildRouter').BotContext} BotContext */
+/** @typedef {import('../Router').Resolver} Resolver */
+
+/**
+ *
+ * @param {object} params
+ * @param {BotContext} context
+ * @returns {Resolver}
+ */
+function media (params, context = {}) {
+    const { isLastIndex } = context;
     const { type, url } = params;
 
     const urlString = url || '';
@@ -24,14 +30,14 @@ function media (
         throw new Error(`Unsupported media type: ${type}`);
     }
 
-    const condition = getCondition(params, 'Media condition');
+    const condition = getCondition(params, context, 'Media condition');
 
     return (req, res) => {
         if (condition && !condition(req, res)) {
             return ret;
         }
 
-        const data = stateData(req, res);
+        const data = stateData(req, res, context.configuration);
         const sendUrl = urlTemplate(data);
 
         res[type](sendUrl, true);

package/src/resolvers/message.js

@@ -44,10 +44,10 @@ function getVoiceControlFromParams (params, lang = null) {
     return Object.keys(voiceControl).length > 0 ? voiceControl : null;
 }
 
-function parseReplies (replies, linksMap, allowForbiddenSnippetWords) {
+function parseReplies (replies, linksMap, context) {
     return replies.map((reply) => {
 
-        const condition = getCondition(reply, 'Quick reply condition', allowForbiddenSnippetWords);
+        const condition = getCondition(reply, context, 'Quick reply condition');
 
         if (reply.isLocation) {
             return {
@@ -78,6 +78,10 @@ function parseReplies (replies, linksMap, allowForbiddenSnippetWords) {
             }
         }
 
+        if (!action) {
+            return null;
+        }
+
         const ret = {
             action,
             condition,
@@ -104,7 +108,8 @@ function parseReplies (replies, linksMap, allowForbiddenSnippetWords) {
         }
 
         return ret;
-    });
+    })
+        .filter((r) => r !== null);
 }
 
 /**
@@ -154,11 +159,20 @@ function findSupportedMessages (text, features, lang = null) {
     };
 }
 
-function message (params, {
-    // @ts-ignore
-    isLastIndex, isLastMessage, linksMap, allowForbiddenSnippetWords
-} = {}) {
+/** @typedef {import('../BuildRouter').BotContext} BotContext */
+/** @typedef {import('../Router').Resolver} Resolver */
 
+/**
+ *
+ * @param {object} params
+ * @param {BotContext} context
+ * @returns {Resolver}
+ */
+function message (params, context = {}) {
+    const {
+        // @ts-ignore
+        isLastIndex, isLastMessage, linksMap, configuration
+    } = context;
     if (typeof params.text !== 'string' && !Array.isArray(params.text)) {
         throw new Error('Message should be a text!');
     }
@@ -168,11 +182,11 @@ function message (params, {
     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);
+        quickReplies = parseReplies(params.replies, linksMap, context);
     }
 
     // compile condition
-    const condition = getCondition(params, 'Message condition', allowForbiddenSnippetWords);
+    const condition = getCondition(params, context, 'Message condition');
 
     const ret = isLastIndex ? Router.END : Router.CONTINUE;
 
@@ -184,7 +198,7 @@ function message (params, {
         if (condition && !condition(req, res)) {
             return ret;
         }
-        const data = stateData(req, res);
+        const data = stateData(req, res, configuration);
 
         // filter supported messages
         const supportedText = findSupportedMessages(

package/src/resolvers/postback.js

@@ -7,7 +7,17 @@ const Router = require('../Router');
 const getCondition = require('../utils/getCondition');
 const { shouldExecuteResolver } = require('./resolverTags');
 
-function postback (params, { linksMap, isLastIndex, allowForbiddenSnippetWords }) {
+/** @typedef {import('../BuildRouter').BotContext} BotContext */
+/** @typedef {import('../Router').Resolver} Resolver */
+
+/**
+ *
+ * @param {object} params
+ * @param {BotContext} context
+ * @returns {Resolver}
+ */
+function postback (params, context) {
+    const { linksMap, isLastIndex } = context;
     const {
         routeId,
         postBack: staticAction
@@ -22,12 +32,12 @@ function postback (params, { linksMap, isLastIndex, allowForbiddenSnippetWords }
         }
     }
 
-    const condition = getCondition(params, '', allowForbiddenSnippetWords);
+    const condition = getCondition(params, context, 'postback');
 
     const ret = isLastIndex ? Router.END : Router.CONTINUE;
 
     return (req, res, postBack) => {
-        if (!shouldExecuteResolver(req, params)) {
+        if (!action || !shouldExecuteResolver(req, params)) {
             return ret;
         }
 

package/src/resolvers/setState.js

@@ -8,11 +8,20 @@ const Ai = require('../Ai');
 const { getSetState } = require('../utils/getUpdate');
 const getCondition = require('../utils/getCondition');
 
-function setState (params, { isLastIndex, allowForbiddenSnippetWords }) {
+/** @typedef {import('../BuildRouter').BotContext} BotContext */
+/** @typedef {import('../Router').Resolver} Resolver */
+
+/**
+ *
+ * @param {object} params
+ * @param {BotContext} context
+ * @returns {Resolver}
+ */
+function setState (params, context) {
 
-    const condition = getCondition(params, '', allowForbiddenSnippetWords);
+    const condition = getCondition(params, context, 'setState');
 
-    const ret = isLastIndex ? Router.END : Router.CONTINUE;
+    const ret = context.isLastIndex ? Router.END : Router.CONTINUE;
 
     return async (req, res) => {
         if (condition !== null) {

package/src/resolvers/subscribtions.js

@@ -6,15 +6,24 @@
 const Router = require('../Router');
 const getCondition = require('../utils/getCondition');
 
-function subscribtions (params, { isLastIndex, allowForbiddenSnippetWords }) {
+/** @typedef {import('../BuildRouter').BotContext} BotContext */
+/** @typedef {import('../Router').Resolver} Resolver */
+
+/**
+ *
+ * @param {object} params
+ * @param {BotContext} context
+ * @returns {Resolver}
+ */
+function subscribtions (params, context) {
     const {
         tags = [],
         unsetTag = false
     } = params;
 
-    const condition = getCondition(params, '', allowForbiddenSnippetWords);
+    const condition = getCondition(params, context, 'subscribtions');
 
-    const ret = isLastIndex ? Router.END : Router.CONTINUE;
+    const ret = context.isLastIndex ? Router.END : Router.CONTINUE;
     const method = unsetTag ? 'unsubscribe' : 'subscribe';
 
     return async (req, res) => {
@@ -35,6 +44,7 @@ function subscribtions (params, { isLastIndex, allowForbiddenSnippetWords }) {
         }
 
         if (tags.length === 0 && unsetTag) {
+            // @ts-ignore
             res.unsubscribe();
         }
 

package/src/resolvers/utils.js

@@ -205,18 +205,18 @@ function getText (text, state) {
 // eslint-disable-next-line no-unused-vars
 const DEFAULT_LINK_TRANSLATOR = (senderId, defaultText, urlText, isExtUrl, reqState) => urlText;
 
+/** @typedef {import('../BuildRouter').BotContext} BotContext */
+
 function processButtons (
     buttons,
     state,
     elem,
-    linksMap,
     senderId,
-    linksTranslator,
-    allowForbiddenSnippetWords,
+    context,
     req,
     res
 ) {
-    const translateLinks = linksTranslator || DEFAULT_LINK_TRANSLATOR;
+    const translateLinks = context.linksTranslator || DEFAULT_LINK_TRANSLATOR;
 
     buttons.forEach(({
         title: btnTitle,
@@ -230,7 +230,7 @@ function processButtons (
         if (hasCondition) {
             const condition = getCondition({
                 hasCondition, conditionFn, hasEditableCondition, editableCondition
-            }, 'Quick reply condition', allowForbiddenSnippetWords);
+            }, context, 'Quick reply condition');
 
             if (!condition(req, res)) {
                 return;
@@ -259,7 +259,7 @@ function processButtons (
                 break;
             }
             case TYPE_POSTBACK: {
-                let postbackAction = linksMap.get(targetRouteId) || action;
+                let postbackAction = context.linksMap.get(targetRouteId) || action;
 
                 if (postbackAction === '/') {
                     postbackAction = './';

package/src/utils/customCondition.js

@@ -148,15 +148,16 @@ const compare = (variable, operator, value = undefined) => {
 /**
  *
  * @param {{value:string, operator:string, variable:string}[][]} condition
+ * @param {object} configuration
  * @param {string} description
  */
-function customCondition (condition, description = '') {
+function customCondition (condition, configuration, description = '') {
     if (typeof condition !== 'object' || !Array.isArray(condition)) {
         throw new Error(`Invalid condition (${description}) type`);
     }
 
     const resolver = (req, res) => condition.some((condList) => condList.every((cond) => {
-        const data = stateData(req, res);
+        const data = stateData(req, res, configuration);
         const variableValue = getValue(cond.variable, data);
         const isRegExp = [
             ConditionOperators['matches regexp'],

package/src/utils/getCondition.js

@@ -6,7 +6,20 @@
 const customCondition = require('./customCondition');
 const customFn = require('./customFn');
 
-module.exports = (params, description = '', allowForbiddenSnippetWords = false) => {
+/** @typedef {import('../BuildRouter').BotContext} BotContext */
+
+/**
+ *
+ * @param {object} params
+ * @param {BotContext} context
+ * @param {string} description
+ * @returns {Function}
+ */
+module.exports = function getCondition (params, context, description = '') {
+    const {
+        allowForbiddenSnippetWords = false,
+        configuration
+    } = context;
     const {
         hasCondition = false,
         conditionFn = '() => true',
@@ -18,7 +31,7 @@ module.exports = (params, description = '', allowForbiddenSnippetWords = false)
 
     if (hasCondition) {
         if (hasEditableCondition) {
-            condition = customCondition(editableCondition);
+            condition = customCondition(editableCondition, configuration, description);
         } else {
             condition = customFn(conditionFn, description, allowForbiddenSnippetWords);
         }

package/src/utils/getUpdate.js

@@ -20,7 +20,7 @@ const UNSUBSCRIBE = '_$unsubscribe';
 
 function getUpdate (attr, value, currentState = {}) {
     let param;
-    let rest = attr;
+    let rest = attr && attr.replace(/\u2219/g, '.');
     let state = currentState;
     const ret = {};
     let up = ret;
@@ -53,7 +53,7 @@ function getUpdate (attr, value, currentState = {}) {
 
 function getValue (attr, currentState = {}) {
     let param;
-    let rest = attr;
+    let rest = attr && attr.replace(/\u2219/g, '.');
     let state = currentState;
 
     do {
@@ -88,7 +88,7 @@ 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, configuration = null) {
     if (!setState) {
         return {};
     }
@@ -179,7 +179,7 @@ function getSetState (setState, req, res = null, useState = null) {
                         values = [];
                     } else {
                         const useValue = typeof value === 'string'
-                            ? handlebars.compile(value)(stateData(req, res))
+                            ? handlebars.compile(value)(stateData(req, res, configuration))
                                 .split(/(?<!\\),/g)
                                 .map((v) => v.replace(/\\,/g, ',').trim())
                             : value;
@@ -205,7 +205,7 @@ function getSetState (setState, req, res = null, useState = null) {
                 set = val;
             }
         } else if (typeof val === 'string') {
-            set = handlebars.compile(val)(stateData(req, res));
+            set = handlebars.compile(val)(stateData(req, res, configuration));
         } else if (val === null
             || SCALAR_TYPES.includes(typeof val)) {
             set = val;

package/src/utils/stateData.js

@@ -3,11 +3,14 @@
  */
 'use strict';
 
-module.exports = function stateData (req, res = null) {
+module.exports = function stateData (req, res = null, configuration = null) {
+    const c = configuration || req.configuration;
     return {
         ...req.state,
         ...(res ? res.newState : {}),
         ...req.actionData(),
-        ...(res ? res.data : {})
+        ...(res ? res.data : {}),
+        c,
+        configuration: c
     };
 };