wingbot 3.39.0-alpha.1 → 3.39.0-alpha.3

package/package.json

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

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

@@ -0,0 +1,44 @@
+const { StepState, StepType, getNextStep } = require('../../src/utils/slots');
+const { vars } = require('../../src/utils/stateVariables');
+
+/** @typedef {import('../../src/Router').Resolver} Resolver */
+/** @typedef {import('../../src/Responder')} Responder */
+/** @typedef {import('../../src/utils/slots').SlotBotState} SlotBotState */
+/** @typedef {import('../../src/utils/slots').SlotsResolver} SlotsResolver */
+/** @typedef {import('../../src/utils/slots').SlotsRequest} SlotsRequest */
+
+/**
+ * @returns {SlotsResolver}
+ */
+function slotContinue () {
+
+    /**
+     * @param {SlotsRequest} req
+     * @param {Responder} res
+     * @param {Function} postBack
+     * @returns {Promise}
+     */
+    async function slotContinuePlugin (req, res, postBack) {
+        const state = { ...req.state, ...res.newState };
+
+        const { _slotStep: step } = state;
+        let { _slotState: slotState } = state;
+
+        if (!step || !slotState) {
+            const msg = 'ERROR: slot filling was not initialized (use the "continue" plugin after the "initialize")';
+            res.text(msg);
+            throw new Error(msg);
+        }
+        slotState = slotState.map((s) => (s.e === step.entity
+            ? { ...s, s: StepState.FILLED }
+            : s));
+
+        res.setState({ _slotState: slotState });
+
+        return getNextStep(req, res, postBack);
+    }
+
+    return slotContinuePlugin;
+}
+
+module.exports = slotContinue;

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

@@ -0,0 +1,89 @@
+const { webalize } = require('webalize');
+const { ai } = require('../../src/Ai');
+const Router = require('../../src/Router');
+const { StepState, StepType, getNextStep } = require('../../src/utils/slots');
+const { vars } = require('../../src/utils/stateVariables');
+
+/** @typedef {import('../../src/utils/slots').SlotsResolver} SlotsResolver */
+/** @typedef {import('../../src/utils/slots').SlotPluginConfig} SlotPluginConfig */
+/** @typedef {import('../../src/utils/slots').SlotBotState} SlotBotState */
+/** @typedef {import('../../src/utils/slots').SlotState} SlotState */
+
+/**
+ *
+ * @param {SlotPluginConfig} params
+ * @returns {Router<SlotBotState>}
+ */
+function slotsRegister ({
+    steps = [],
+    doneAction,
+    intents = ''
+}) {
+
+    const useIntents = intents.split(',')
+        .map((i) => i.trim());
+
+    /** @type {Router<SlotBotState>} */
+    const bot = new Router();
+
+    const setEntities = [];
+
+    /** @type {SlotsResolver} */
+    const handler = async (req, res, postBack) => {
+        // offer rooms or (does'nt matter)
+
+        /** @type {SlotState[]} */
+        const slotState = steps.map((step) => {
+            const entity = step.entity.replace(/^@/, '');
+            const entities = req.entities.filter((e) => e.entity === entity)
+                .map((e) => e.value);
+
+            if (entities.length === 0) {
+                return {
+                    e: step.entity,
+                    s: step.type === StepType.ADDITIONAL
+                        ? StepState.FILLED
+                        : StepState.INITIALIZED
+                };
+            }
+
+            if (step.type === StepType.MULTI) {
+                setEntities.push(vars.dialogContext(`+${entity}`, entities, true));
+            } else {
+                setEntities.push(vars.dialogContext(step.entity, entities[0], true));
+            }
+
+            return {
+                e: step.entity,
+                s: step.validateAction ? StepState.FILLED : StepState.VALID
+            };
+        });
+
+        res.setState({
+            _slotState: slotState,
+            _slotSteps: steps,
+            _slotDone: doneAction,
+            ...Object.fromEntries(
+                steps.map(({ entity, type }) => (type === StepType.MULTI
+                    ? [entity.replace(/^@/, '+'), []]
+                    : [entity, null]))
+            ),
+            ...setEntities.reduce((o, r) => Object.assign(o, r), {})
+        });
+
+        return getNextStep(req, res, postBack);
+    };
+
+    bot.use(ai.global('/', useIntents), handler);
+
+    for (const step of steps) {
+        bot.use(
+            ai.global(webalize(step.entity), [...useIntents, step.entity]),
+            handler
+        );
+    }
+
+    return bot;
+}
+
+module.exports = slotsRegister;

package/plugins/plugins.json

@@ -375,6 +375,81 @@
                     "label": "Text to test (keep empty to use user input)"
                 }
             ]
+        },
+        {
+            "id": "ai.wingbot.slotsRegister",
+            "name": "Slot filling: register",
+            "description": "Sets up slot filling conversation for a list of entities",
+            "availableSince": 3.39,
+            "editable": false,
+            "isFactory": true,
+            "category": "conversation",
+            "inputs": [
+                {
+                    "type": "text",
+                    "name": "intents",
+                    "label": "Intent list (comma separated)",
+                    "validations": [
+                        { "type": "regexp", "value": "^[^\\s]+$", "message": "intent for slot filling should not be empty" }
+                    ]
+                },
+                {
+                    "type": "postback",
+                    "name": "doneAction",
+                    "label": "Continue here, when finished"
+                },
+                {
+                    "type": "array",
+                    "name": "steps",
+                    "label": "Slot",
+                    "keyPropertyName": "entity",
+                    "inputs": [
+                        {
+                            "type": "text",
+                            "name": "entity",
+                            "label": "Entity (with @)",
+                            "validations": [
+                                { "type": "regexp", "value": "^@[a-zA-Z0-9-]+$", "message": "the entity for the slot filling should be valid" }
+                            ]
+                        },
+                        {
+                            "type": "select",
+                            "name": "type",
+                            "label": "Question",
+                            "options": [
+                                { "label": "Required", "value": "req" },
+                                { "label": "Multi value", "value": "mul" },
+                                { "label": "Additional", "value": "add" }
+                            ]
+                        },
+                        {
+                            "type": "postback",
+                            "name": "askAction",
+                            "label": "Question"
+                        },
+                        {
+                            "type": "postback",
+                            "optional": true,
+                            "name": "validateAction",
+                            "label": "Validation"
+                        }
+                    ]
+                }
+            ],
+            "items": [
+            ]
+        },
+        {
+            "id": "ai.wingbot.slotsContinue",
+            "name": "Slot filling: continue",
+            "description": "move the slot filling to the next step",
+            "availableSince": 3.39,
+            "editable": false,
+            "isFactory": true,
+            "inputs": [
+            ],
+            "items": [
+            ]
         }
     ],
     "categories": [

package/src/AiMatching.js

@@ -191,7 +191,7 @@ class AiMatching {
         return returnIfEmpty;
     }
 
-    _hbsOrFn (value, cb) {
+    _hbsOrFn (value) {
         if (typeof value === 'string') {
             let useValue = value;
             if (useValue.match(/^\$[a-zA-Z0-9_-]+$/)) {
@@ -199,13 +199,12 @@ class AiMatching {
             }
             if (useValue.match(/\{\{.+\}\}/)) {
                 const compiler = handlebars.compile(useValue);
-                return (data) => {
-                    const res = compiler(data);
-                    return cb(res);
-                };
+                // @ts-ignore
+                compiler.template = useValue;
+                return compiler;
             }
         }
-        return cb(value);
+        return value;
     }
 
     _normalizeComparisonArray (compare, op) {
@@ -220,7 +219,7 @@ class AiMatching {
             const [val] = arr;
 
             return [
-                this._hbsOrFn(val, (r) => this._normalizeToNumber(r, 0))
+                this._hbsOrFn(val)
             ];
         }
 
@@ -228,12 +227,12 @@ class AiMatching {
             const [min, max] = arr;
 
             return [
-                this._hbsOrFn(min, (r) => this._normalizeToNumber(r, -Infinity)),
-                this._hbsOrFn(max, (r) => this._normalizeToNumber(r, Infinity))
+                this._hbsOrFn(min),
+                this._hbsOrFn(max)
             ];
         }
 
-        return arr.map((cmp) => this._hbsOrFn(cmp, (r) => `${r}`));
+        return arr.map((cmp) => this._hbsOrFn(cmp));
     }
 
     _stringOpToOperation (op) {
@@ -285,6 +284,7 @@ class AiMatching {
      */
     getSetStateForEntityRules ({ entities }) {
         return entities.reduce((o, rule) => {
+
             if (rule instanceof RegExp) {
                 return o;
             }
@@ -297,13 +297,13 @@ class AiMatching {
 
             if (rule.op === COMPARE.EQUAL
                 && rule.compare
-                && rule.compare.length === 1
-                && typeof rule.compare[0] !== 'function') {
+                && rule.compare.length === 1) {
 
                 const key = `@${rule.entity}`;
                 const value = rule.compare[0];
 
-                return Object.assign(o, vars.dialogContext(key, value));
+                // @ts-ignore
+                return vars.dialogContext(key, value && (value.template || value));
             }
             return o;
         }, {});
@@ -732,11 +732,15 @@ class AiMatching {
                 : false;
         }
 
-        const useCmp = (compare || [])
+        let useCmp = (compare || [])
             .map((c) => (typeof c === 'function'
                 ? c(requestState)
                 : c));
 
+        if ([COMPARE.EQUAL, COMPARE.NOT_EQUAL].includes(operation)) {
+            useCmp = useCmp.map((c) => (typeof c === 'string' ? c : `${c}`));
+        }
+
         switch (operation) {
             case COMPARE.EQUAL:
                 return useCmp.length === 0 || useCmp.includes(`${value}`);
@@ -748,7 +752,8 @@ class AiMatching {
                 if (normalized === null) {
                     return false;
                 }
-                return normalized >= min && normalized <= max;
+                return normalized >= this._normalizeToNumber(min, -Infinity)
+                    && normalized <= this._normalizeToNumber(max, Infinity);
             }
             case COMPARE.GT:
             case COMPARE.LT:
@@ -759,7 +764,7 @@ class AiMatching {
                 if (normalized === null) {
                     return false;
                 }
-                return this._numberComparison(op, cmp, normalized);
+                return this._numberComparison(op, this._normalizeToNumber(cmp, 0), normalized);
             }
             default:
                 return true;

package/src/Processor.js

@@ -1,4 +1,4 @@
-/*
+/**
  * @author David Menger
  */
 'use strict';

package/src/Request.js

@@ -1137,7 +1137,15 @@ class Request {
             let { setState = {} } = res;
             for (const gi of this.globalIntents.values()) {
                 if (gi.action === res.action) {
-                    ({ entitiesSetState } = gi);
+                    entitiesSetState = { ...gi.entitiesSetState };
+
+                    const values = Array.from(Object.values(entitiesSetState));
+
+                    for (const value of values) {
+                        if (typeof value === 'function') {
+                            Object.assign(entitiesSetState, value(stateData(this)));
+                        }
+                    }
                 }
             }
             const newState = {

package/src/Tester.js

@@ -290,6 +290,14 @@ class Tester {
             || (!botAction.match(/\*/) && actionMatches(botAction, path));
     }
 
+    _actionsDebug (matchRequestActions = false) {
+        const set = new Set();
+        return this.actions
+            .filter((a) => !a.isReqAction || matchRequestActions)
+            .map((a) => (a.doNotTrack ? `(system interaction) ${a.action}` : a.action))
+            .filter((a) => !set.has(a) && set.add(a));
+    }
+
     /**
      * Checks, that request passed an interaction
      *
@@ -305,11 +313,7 @@ class Tester {
                 && this._actionMatches(action.action, path));
         let actual;
         if (!ok) {
-            const set = new Set();
-            actual = this.actions
-                .filter((a) => !a.isReqAction || matchRequestActions)
-                .map((a) => (a.doNotTrack ? `(system interaction) ${a.action}` : a.action))
-                .filter((a) => !set.has(a) && set.add(a));
+            actual = this._actionsDebug(matchRequestActions);
             assert.fail(asserts.ex('Interaction was not passed', path, actual));
         }
         return this;
@@ -419,6 +423,22 @@ class Tester {
             .intentWithEntity(this.senderId, text, intent, entity, value, score));
     }
 
+    /**
+     * Makes recognised AI request with entity
+     *
+     * @param {string} entity
+     * @param {string} [value]
+     * @param {string} [text]
+     * @param {number} [score]
+     * @returns {Promise}
+     *
+     * @memberOf Tester
+     */
+    entity (entity, value = entity, text = value, score = 1) {
+        return this.processMessage(Request
+            .intentWithEntity(this.senderId, text, `random-${Date.now()}`, entity, value, score));
+    }
+
     /**
      * Make optin call
      *
@@ -523,6 +543,27 @@ class Tester {
             .postBack(this.senderId, action, data, refAction, refData, null));
     }
 
+    /**
+     * Prints last conversation turnaround
+     *
+     * @param {boolean} [showPrivateKeys]
+     */
+    debug (showPrivateKeys = false) {
+        // eslint-disable-next-line no-console
+        console.log(
+            '\n===== actions =====\n',
+            this._actionsDebug(true),
+            '\n---- responses ----\n',
+            this.responses.map(({ messaging_type: m, recipient, ...o }) => o),
+            '\n------ state ------\n',
+            Object.fromEntries(
+                Object.entries(this.getState().state)
+                    .filter((e) => showPrivateKeys || !e[0].startsWith('_'))
+            ),
+            '\n===================\n'
+        );
+    }
+
 }
 
 module.exports = Tester;

package/src/resolvers/message.js

@@ -286,6 +286,10 @@ function message (params, context = {}) {
 
         res.text(text, sendReplies, voiceControl);
 
+        if (isLastMessage && !req.actionData()._resolverTag) {
+            res.finalMessageSent = true;
+        }
+
         return ret;
     };
 }

package/src/testTools/asserts.js

@@ -30,8 +30,8 @@ function m (text, actual = null, expected = null) {
 
 function ex (message, expected, actual) {
     const actuals = Array.isArray(actual) ? actual : [actual];
-    return `${message}\n  + expected: "${expected}"\n  - actual: ${actuals
-        .map((a) => `"${a}"`).join('\n            ')}`;
+    return `${message}\n  + expected: "${expected}"\n  - actual:   ${actuals
+        .map((a) => `"${a}"`).join('\n              ')}`;
 }
 
 function getText (response) {

package/src/utils/getUpdate.js

@@ -13,7 +13,7 @@ try {
     handlebars = { compile: (text) => () => text };
 }
 
-const ATTR_REGEX = /^([^.+]*)\.?(.+)?$/;
+const ATTR_REGEX = /^([^.]*)\.?(.+)?$/;
 const SCALAR_TYPES = ['string', 'number', 'boolean'];
 const SUBSCRIBE = '_$subscribe';
 const UNSUBSCRIBE = '_$unsubscribe';

package/src/utils/quickReplies.js

@@ -208,6 +208,7 @@ function makeQuickReplies (replies, path = '', translate = (w) => w, quickReplyC
                                 }
                                 return o;
                             }, {});
+
                         setState = {
                             ...entitiesSetState,
                             ...setState

package/src/utils/slots.js

@@ -0,0 +1,113 @@
+/**
+ * @author {David Menger}
+ */
+'use strict';
+
+const Router = require('../Router');
+const Request = require('../Request'); // eslint-disable-line no-unused-vars
+
+/** @typedef {import('../Responder')} Responder */
+
+/**
+ * @readonly
+ * @enum {string}
+ */
+const StepType = {
+    REQUIRED: 'req',
+    MULTI: 'mul',
+    ADDITIONAL: 'add'
+};
+
+/**
+ * @readonly
+ * @enum {string}
+ */
+const StepState = {
+    INITIALIZED: 'i',
+    FILLED: 'f',
+    VALID: 'v'
+};
+
+/**
+ * @typedef {object} SlotStep
+ * @prop {string} entity
+ * @prop {StepType} type
+ * @prop {string} [validateAction]
+ * @prop {string} askAction
+ */
+
+/**
+ * @typedef {object} SlotState
+ * @prop {string} e
+ * @prop {StepState} s
+ */
+
+/**
+ * @typedef {object} SlotBotState
+ * @prop {SlotState[]} _slotState
+ * @prop {SlotStep} [_slotStep]
+ * @prop {SlotStep[]} [_slotSteps]
+ * @prop {string} [_slotDone]
+ */
+
+/**
+ * @typedef {object} SlotPluginConfig
+ * @prop {SlotStep[]} steps
+ * @prop {string} doneAction
+ * @prop {string} intents
+ */
+
+/** @typedef {import('../Router').Resolver<SlotBotState>} SlotsResolver */
+/** @typedef {Request<SlotBotState>} SlotsRequest */
+
+/**
+ * @param {Request<SlotBotState>} req
+ * @param {Responder} res
+ * @param {Function} postBack
+ * @returns {Promise}
+ */
+async function getNextStep (req, res, postBack) {
+    let invalid = null;
+    const {
+        _slotState: slotState, _slotSteps: steps, _slotDone: doneAction
+    } = { ...req.state, ...res.newState };
+
+    for (const slot of slotState) {
+        const step = steps.find((s) => s.entity === slot.e);
+        if (slot.s === StepState.FILLED && step && step.validateAction) {
+            // eslint-disable-next-line
+            await postBack(step.validateAction, {}, true);
+            if (res.finalMessageSent) {
+                invalid = step;
+                break;
+            }
+            slot.s = StepState.VALID;
+        } else if (slot.s === StepState.FILLED) {
+            slot.s = StepState.VALID;
+        }
+    }
+
+    res.setState({ _slotState: slotState });
+
+    if (invalid) {
+        res.setState({ _slotStep: invalid });
+        return Router.END;
+    }
+
+    const nextStep = slotState.find((s) => s.s !== StepState.VALID);
+
+    if (!nextStep) {
+        postBack(doneAction);
+        return Router.END;
+    }
+    const stepConfig = steps.find((s) => s.entity === nextStep.e);
+    res.setState({ _slotStep: stepConfig });
+    postBack(stepConfig.askAction);
+    return Router.END;
+}
+
+module.exports = {
+    getNextStep,
+    StepState,
+    StepType
+};

package/src/utils/stateVariables.js

@@ -26,15 +26,19 @@ const vars = {
      *
      * @param {string} key
      * @param {*} value
+     * @param {string} [path]
      * @returns {object}
      * @example
      * const { vars } = require('wingbot');
      * res.setState(vars.dialogContext('myKey', 'foovalue'))
      */
-    dialogContext (key, value) {
+    dialogContext (key, value, path = null) {
         return {
             [key]: value,
-            [`_~${key}`]: { t: DIALOG_CONTEXT }
+            [`_~${key}`]: {
+                t: DIALOG_CONTEXT,
+                ...(path && { p: path })
+            }
         };
     },
 
@@ -166,6 +170,17 @@ function mergeState (previousState, req, res, senderStateUpdate, firstInTurnover
             case DIALOG_CONTEXT: {
                 // compare state
 
+                if (!lastInTurnover || previousState._lastVisitedPath === undefined) {
+                    break;
+                }
+
+                if (value.p === true) {
+                    state[key].p = res.newState._lastVisitedPath;
+                } else if (value.p !== res.newState._lastVisitedPath) {
+                    delete state[key];
+                    delete state[referencedKey];
+                }
+
                 if (lastInTurnover
                     && previousState._lastVisitedPath !== undefined
                     && value.p !== res.newState._lastVisitedPath) {