wingbot 3.30.1 → 3.32.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.30.1",
+  "version": "3.32.0-alpha.1",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "scripts": {
@@ -53,6 +53,7 @@
     "tsd-jsdoc": "^2.5.0"
   },
   "dependencies": {
+    "form-data": "^4.0.0",
     "graphql": "^15.8.0",
     "jsonwebtoken": "^8.5.1",
     "node-fetch": "^2.6.7",

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/BotAppSender.js

@@ -5,6 +5,7 @@
 
 const jwt = require('jsonwebtoken');
 const { default: fetch, Headers } = require('node-fetch');
+const FormData = require('form-data');
 const crypto = require('crypto');
 const { Agent } = require('https');
 const { promisify } = require('util');
@@ -12,6 +13,7 @@ const ReturnSender = require('./ReturnSender');
 
 /** @typedef {import('./ReturnSender').ReturnSenderOptions} ReturnSenderOptions */
 /** @typedef {import('./ReturnSender').ChatLogStorage} ChatLogStorage */
+/** @typedef {import('./ReturnSender').UploadResult} UploadResult */
 
 /**
  * @typedef {object} TlsOptions
@@ -91,6 +93,38 @@ class BotAppSender extends ReturnSender {
         return this._agent;
     }
 
+    /**
+     *
+     * @param {Buffer} data
+     * @param {string} contentType
+     * @param {string} fileName
+     * @returns {Promise<UploadResult>}
+     */
+    async upload (data, contentType, fileName) {
+        const formData = new FormData();
+
+        const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(36).padEnd(11, '0');
+
+        formData.append('nonce', nonce);
+        formData.append('f0', data, { filename: fileName, contentType });
+
+        const [token, agent] = await Promise.all([
+            BotAppSender.signBody(nonce, this._secret, this._appId),
+            this._getAgent()
+        ]);
+
+        const headers = new Headers();
+
+        headers.set('Authorization', token);
+
+        const response = await this._fetch(this._apiUrl, {
+            headers, body: formData, agent, method: 'POST'
+        })
+            .then((r) => r.json());
+
+        return response;
+    }
+
     async _send (payload) {
         // attach sender
         if (typeof payload.sender === 'undefined') {

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,15 @@ 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.config] - context data
+     * @param {object} [context.configuration]
      * @param {fetch} [fetchFn] - override a request function
      * @example
      *
@@ -76,8 +191,10 @@ class BuildRouter extends Router {
 
         this._plugins = plugins;
 
+        /** @type {BotContext} */
         this._context = context;
 
+        /** @type {LinksMap} */
         this._linksMap = new Map();
 
         this._loadBotUrl = null;
@@ -94,7 +211,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 +229,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;
@@ -314,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) {
@@ -388,7 +511,13 @@ class BuildRouter extends Router {
         });
     }
 
+    /**
+     *
+     * @param {Block} block
+     * @returns {LinksMap}
+     */
     _createLinksMap (block) {
+        /** @type {LinksMap} */
         const linksMap = new Map();
 
         block.routes
@@ -400,35 +529,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) {
@@ -436,14 +670,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 = [];
 
@@ -451,10 +691,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) {
@@ -486,8 +726,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;
@@ -515,6 +772,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) {
@@ -524,15 +786,30 @@ class BuildRouter extends Router {
         return -1;
     }
 
-    buildResolvers (resolvers, route = {}, expectedToAddResolver = false) {
+    /**
+     *
+     * @param {Resolver[]} resolvers
+     * @param {TransformedRoute} route
+     * @param {*} expectedToAddResolver
+     * @returns {Middleware[]}
+     */
+    buildResolvers (resolvers, route = DUMMY_ROUTE, expectedToAddResolver = false) {
         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 && !expectedToAddResolver,
@@ -543,13 +820,23 @@ class BuildRouter extends Router {
                 isFallback,
                 isResponder,
                 expectedPath,
-                routeId: id
+                routeId: id,
+                configuration
             };
 
-            return this._resolverFactory(resolver, context);
+            const resFn = this._resolverFactory(resolver, context);
+            // @ts-ignore
+            resFn.configuration = configuration;
+            return resFn;
         });
     }
 
+    /**
+     *
+     * @param {Resolver} resolver
+     * @param {BotContext} context
+     * @returns {Middleware}
+     */
     _resolverFactory (resolver, context) {
         const { type } = resolver;
 
@@ -602,9 +889,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/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

@@ -258,6 +258,9 @@ class Request {
          * @constant {string} FEATURE_TEXT channel supports text communication
          */
         this.FEATURE_TEXT = FEATURE_TEXT;
+
+        /** @type {object} */
+        this.configuration = Object.freeze({});
     }
 
     get data () {

package/src/Responder.js

@@ -60,6 +60,8 @@ Object.freeze(ExpectedInput);
  * @prop {string} [voice]
  */
 
+/** @typedef {import('./ReturnSender').UploadResult} UploadResult */
+
 /**
  * Instance of responder is passed as second parameter of handler (res)
  *
@@ -537,6 +539,7 @@ class Responder {
             });
         } else {
             this._quickReplyCollector.push({
+                // @ts-ignore
                 action: this.toAbsoluteAction(action),
                 title,
                 data,
@@ -749,6 +752,30 @@ class Responder {
         return ret;
     }
 
+    /**
+     *
+     * @param {Buffer} data
+     * @param {string} contentType
+     * @param {string} fileName
+     * @returns {Promise<UploadResult>}
+     */
+    async upload (data, contentType, fileName) {
+        const result = await this._messageSender.upload(data, contentType, fileName);
+
+        if (!result.url) {
+            throw new Error(`Got no url on file upload ${fileName}. Probably a compatibility issue.`);
+        }
+
+        let [type] = contentType.split('/');
+
+        if (!['image', 'video', 'audio'].includes(type)) {
+            type = 'file';
+        }
+
+        this._attachment(result.url, type, true);
+        return result;
+    }
+
     /**
      * Sends image as response. Requires appUrl option to send images from server
      *

package/src/ReturnSender.js

@@ -23,6 +23,12 @@ const { FLAG_DO_NOT_LOG } = require('./flags');
  * @prop {textFilter} [confidentInputFilter] - filter for confident input (@CONFIDENT)
  */
 
+/**
+ * @typedef {object} UploadResult
+ * @prop {string} [url]
+ * @prop {string|number} [attachmentId]
+ */
+
 /**
  * Text filter function
  *
@@ -319,6 +325,17 @@ class ReturnSender {
         this._visitedInteractions.push(action);
     }
 
+    /**
+     *
+     * @param {Buffer} data
+     * @param {string} contentType
+     * @param {string} fileName
+     * @returns {Promise<UploadResult>}
+     */
+    async upload (data, contentType, fileName) { // eslint-disable-line no-unused-vars
+        throw new Error('#upload() not supported by this channel');
+    }
+
     send (payload) {
         if (this._finished) {
             throw new Error('Cannot send message after sender is finished');

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/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

@@ -9,20 +9,27 @@ const Request = require('../Request');
 const Router = require('../Router');
 const getCondition = require('../utils/getCondition');
 const {
-    stateData, getLanguageText, getLanguageTextObjects, randomizedCompiler
+    stateData,
+    getLanguageText,
+    getLanguageTextObjects,
+    randomizedCompiler,
+    cachedTranslatedCompilator
 } = require('./utils');
 const {
     FEATURE_SSML, FEATURE_TEXT, FEATURE_VOICE
 } = require('../features');
 
+/** @typedef {import('../Responder').VoiceControl} VoiceControl */
+/** @typedef {import('./utils').Translations} Translations */
+/** @typedef {import('./utils').TextObject} TextObject */
 /**
  * Returns voice control props from params
  *
  * @param {any} params
  * @param {string} lang
- * @returns {null | import('../Responder').VoiceControl}
+ * @returns {null | VoiceControl}
  */
-function getVoiceControl (params, lang = null) {
+function getVoiceControlFromParams (params, lang = null) {
     const voiceControl = {};
 
     const voiceControlProps = ['speed', 'pitch', 'volume', 'voice', 'style', 'language'];
@@ -37,10 +44,10 @@ function getVoiceControl (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 {
@@ -71,11 +78,15 @@ function parseReplies (replies, linksMap, allowForbiddenSnippetWords) {
             }
         }
 
+        if (!action) {
+            return null;
+        }
+
         const ret = {
             action,
             condition,
             title: reply.title
-                ? randomizedCompiler(reply.title)
+                ? cachedTranslatedCompilator(reply.title)
                 : null,
             data: {}
         };
@@ -97,14 +108,15 @@ function parseReplies (replies, linksMap, allowForbiddenSnippetWords) {
         }
 
         return ret;
-    });
+    })
+        .filter((r) => r !== null);
 }
 
 /**
- * @param {import('./utils').Translations} text
+ * @param {Translations} text
  * @param {string[]} features
  * @param {string} lang
- * @returns {{translations: import('./utils').TextObject[],ssmlAlternatives:string[] | null}}
+ * @returns {{translations:TextObject[],ssmlAlternatives:string[] | null}}
  */
 function findSupportedMessages (text, features, lang = null) {
     let translations = getLanguageTextObjects(text, lang);
@@ -147,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!');
     }
@@ -161,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;
 
@@ -177,10 +198,9 @@ function message (params, {
         if (condition && !condition(req, res)) {
             return ret;
         }
-        const data = stateData(req, res);
+        const data = stateData(req, res, configuration);
 
         // filter supported messages
-        /** @type {{translations:import('./utils').TextObject[],ssmlAlternatives:string[]}} */
         const supportedText = findSupportedMessages(
             params.text,
             req.features,
@@ -231,7 +251,7 @@ function message (params, {
         }
 
         // generate voice control
-        let voiceControl = getVoiceControl(params, data.lang);
+        let voiceControl = getVoiceControlFromParams(params, data.lang);
         if (supportedText.ssmlAlternatives) {
             // find SSML alternative
             const ssmlAlternativeTemplate = randomizedCompiler([{

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

@@ -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
     };
 };