wingbot 3.46.0-alpha.9 → 3.46.1

package/index.js

@@ -48,6 +48,10 @@ const compileWithState = require('./src/utils/compileWithState');
 const onInteractionHandler = require('./src/analytics/onInteractionHandler');
 const GA4 = require('./src/analytics/GA4');
 const plugins = require('./plugins/plugins.json');
+const extractText = require('./src/transcript/extractText');
+const htmlBodyFromTranscript = require('./src/transcript/htmlBodyFromTranscript');
+const textBodyFromTranscript = require('./src/transcript/textBodyFromTranscript');
+const transcriptFromHistory = require('./src/transcript/transcriptFromHistory');
 const {
     bufferloader,
     MemoryStateStorage
@@ -135,5 +139,11 @@ module.exports = {
 
     // ANALYTICS
     onInteractionHandler,
-    GA4
+    GA4,
+
+    // TRANSCRIPTS
+    extractText,
+    htmlBodyFromTranscript,
+    textBodyFromTranscript,
+    transcriptFromHistory
 };

package/package.json

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

package/src/BotApp.js

@@ -104,6 +104,14 @@ class BotApp {
         this._logger = options.log || console;
         this._textFilter = options.textFilter;
 
+        this._preHeatCalled = false;
+        this._preHeat = [
+            this._logger,
+            chatLogStorage,
+            processorOptions.stateStorage,
+            processorOptions.tokenStorage
+        ].filter((s) => s && typeof s.preHeat === 'function');
+
         let { apiUrl } = options;
 
         if (!apiUrl) apiUrl = DEFAULT_API_URL;
@@ -204,6 +212,10 @@ class BotApp {
             analyticsStorage.setDefaultLogger(log);
         }
 
+        if (typeof analyticsStorage.preHeat === 'function') {
+            this._preHeat.push(analyticsStorage);
+        }
+
         // @ts-ignore
         const { snapshot = null, botId = null } = this._bot;
 
@@ -440,6 +452,15 @@ class BotApp {
             return this._errorResponse('Missing authentication header', 401);
         }
 
+        let preHeatPromise = null;
+        if (!this._preHeatCalled) {
+            preHeatPromise = Promise.all(
+                this._preHeat.map((p) => Promise.resolve(p.preHeat())
+                    .catch((e) => this._logger.error('BotApp: preHeat failed', e)))
+            );
+            this._preHeatCalled = true;
+        }
+
         let sha1;
         let appId;
         let secret;
@@ -449,6 +470,7 @@ class BotApp {
             // @ts-ignore
             ({ sha1, appId } = await this._verify(token, secret));
         } catch (e) {
+            await Promise.resolve(preHeatPromise);
             return this._errorResponse(`Failed to verify token: ${e.message}`, 403);
         }
 
@@ -457,22 +479,28 @@ class BotApp {
             .digest('hex');
 
         if (sha1 !== bodySha1) {
+            await Promise.resolve(preHeatPromise);
             return this._errorResponse(`SHA1 does not match. Got in token: '${sha1}'`, 403);
         }
 
-        const body = JSON.parse(rawBody);
-
-        const entry = await this._processEntries(appId, secret, body.entry, rawHeaders);
+        try {
+            const body = JSON.parse(rawBody);
 
-        return {
-            statusCode: 200,
-            body: JSON.stringify({
-                entry
-            }),
-            headers: {
-                'Content-Type': 'application/json'
-            }
-        };
+            const entry = await this._processEntries(appId, secret, body.entry, rawHeaders);
+            await Promise.resolve(preHeatPromise);
+            return {
+                statusCode: 200,
+                body: JSON.stringify({
+                    entry
+                }),
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            };
+        } catch (e) {
+            await Promise.resolve(preHeatPromise);
+            throw e;
+        }
     }
 
     async _processEntries (appId, secret, entry = [], headers = {}) {

package/src/Processor.js

@@ -62,6 +62,7 @@ const { mergeState, isUserInteraction } = require('./utils/stateVariables');
  * @prop {TrackingEvent[]} events
  * @prop {ResponseFlag|null} flag
  * @prop {boolean} nonInteractive
+ * @prop {string[]} responseTexts
  */
 
 /**
@@ -434,6 +435,7 @@ class Processor extends EventEmitter {
         const { events = [] } = messageSender.tracking;
 
         const event = {
+            responseTexts: messageSender.responseTexts,
             req,
             actions,
             lastAction,

package/src/ReturnSender.js

@@ -6,6 +6,7 @@
 const ai = require('./Ai');
 const { FEATURE_PHRASES, FEATURE_TRACKING } = require('./features');
 const { ResponseFlag } = require('./analytics/consts');
+const extractText = require('./transcript/extractText');
 
 /** @typedef {import('./Request')} Request */
 /** @typedef {import('./Responder')} Responder */
@@ -122,8 +123,12 @@ class ReturnSender {
             events: []
         };
 
+        this._responseTexts = [];
+
         this._intentsAndEntities = [];
 
+        this._confidentInput = false;
+
         /**
          * @type {Function}
          * @private
@@ -147,6 +152,19 @@ class ReturnSender {
         return this._simulatesOptIn;
     }
 
+    /**
+     * @returns {string[]}
+     */
+    get responseTexts () {
+        const filter = this._confidentInput
+            ? this.confidentInputFilter
+            : this.textFilter;
+
+        return this._responseTexts
+            .map((t) => filter(t))
+            .filter((t) => t && `${t}`.trim());
+    }
+
     _gotAnotherEvent () {
         if (this._gotAnotherEventDefer) {
             this._gotAnotherEventDefer();
@@ -379,6 +397,10 @@ class ReturnSender {
             return;
         }
 
+        const text = extractText(payload);
+        if (text) {
+            this._responseTexts.push(text);
+        }
         this._queue.push(payload);
         this._gotAnotherEvent();
 
@@ -509,7 +531,7 @@ class ReturnSender {
     async finished (req = null, res = null, err = null, reportError = console.error) {
         this._finish(req);
         const meta = this._createMeta(req, res);
-        const confidentInput = req && req.isConfidentInput();
+        this._confidentInput = !!req && req.isConfidentInput();
         let error = err;
         try {
             await this._promise;
@@ -526,7 +548,7 @@ class ReturnSender {
             const processedEvent = req
                 ? req.event
                 : this._incommingMessage;
-            let incomming = this._filterMessage(processedEvent, confidentInput, req);
+            let incomming = this._filterMessage(processedEvent, this._confidentInput, req);
 
             if (processedEvent !== this._incommingMessage) {
                 incomming = {

package/src/analytics/onInteractionHandler.js

@@ -75,8 +75,6 @@ const {
  * @prop {boolean} nonInteractive
  * @prop {boolean} isGoto
  * @prop {boolean} withUser
- * @prop {string} [snapshot]
- * @prop {string} [botId]
  *
  * @typedef {Event & PageViewEventExtension} PageViewEvent
  */
@@ -96,6 +94,8 @@ const {
  * @prop {number|null} [feedback]
  * @prop {string} [timeZone]
  * @prop {number} [sessionStart]
+ * @prop {number} [sessionDuration]
+ * @prop {string[]} [responseTexts]
  */
 
 /**
@@ -138,6 +138,7 @@ const {
  * @prop {boolean} [useDescriptiveCategories]
  * @prop {boolean} [useExtendedScalars]
  * @prop {boolean} [parallelSessionInsert]
+ * @prop {Function} [preHeat]
  */
 
 /**
@@ -237,7 +238,8 @@ function onInteractionHandler (
         skill,
         events,
         flag,
-        nonInteractive
+        nonInteractive,
+        responseTexts
     }) {
         if (!enabled) {
             return;
@@ -293,6 +295,7 @@ function onInteractionHandler (
                 feedback,
                 timeZone,
                 sessionStart,
+                responseTexts,
                 sessionDuration: sessionTs - sessionStart
             };
 
@@ -426,6 +429,7 @@ function onInteractionHandler (
                         prevAction,
                         skill: useSkill,
                         isGoto: true,
+                        withUser,
                         ...langsExtension
                     };
 

package/src/tools/MemoryChatLogStorage.js

@@ -0,0 +1,70 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+/**
+ * @class MemoryChatLogStorage
+ */
+class MemoryChatLogStorage {
+
+    constructor () {
+        this._logs = new Map();
+    }
+
+    /**
+     * Interate history
+     * all limits are inclusive
+     *
+     * @param {string} senderId
+     * @param {string} pageId
+     * @param {number} [limit]
+     * @param {number} [endAt] - iterate backwards to history
+     * @param {number} [startAt] - iterate forward to last interaction
+     * @returns {Promise<object[]>}
+     */
+    async getInteractions (senderId, pageId, limit = 10, endAt = null, startAt = null) { // eslint-disable-line max-len,no-unused-vars
+        const events = this._getEvents(senderId);
+        return events.slice(-limit);
+    }
+
+    /**
+     *
+     * @param {string} senderId
+     * @returns {object[]}
+     */
+    _getEvents (senderId) {
+        let events = this._logs.get(senderId);
+        if (!events) {
+            events = [];
+            this._logs.set(senderId, events);
+        }
+        return events;
+    }
+
+    /**
+     * Log single event
+     *
+     * @param {string} senderId
+     * @param {object[]} responses - list of sent responses
+     * @param {object} request - event request
+     * @param {object} [metadata] - request metadata
+     * @returns {void}
+     */
+    log (senderId, responses = [], request = {}, metadata = {}) {
+        const events = this._getEvents(senderId);
+        events.push({
+            senderId,
+            request,
+            responses,
+            ...metadata
+        });
+    }
+
+    error (error, senderId, sent, incomming, meta) {
+        return this.log(senderId, sent, incomming, { ...meta, error });
+    }
+
+}
+
+module.exports = MemoryChatLogStorage;

package/src/transcript/extractText.js

@@ -0,0 +1,54 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+/**
+ * Extracts text from conversational event
+ *
+ * @param {object} payload
+ * @returns {string|null}
+ */
+function extractText (payload) {
+
+    // text message
+    if (payload.message && payload.message.text) {
+        return payload.message.text;
+    }
+
+    // button message
+    if (payload.message && payload.message.attachment
+        && payload.message.attachment.type === 'template'
+        && payload.message.attachment.payload
+        && payload.message.attachment.payload.text) {
+
+        return payload.message.attachment.payload.text;
+    }
+
+    if (!payload.postback) {
+        return null;
+    }
+
+    // postback with title
+    if (payload.postback.title) {
+        return payload.postback.title;
+    }
+
+    if (payload.postback.payload && payload.postback.payload.action) {
+        return payload.postback.payload.action;
+    }
+
+    if (typeof payload.postback.payload !== 'string') {
+        return null;
+    }
+
+    if (payload.postback.payload[0] === '{') {
+        const pl = JSON.parse(payload.postback.payload);
+
+        return pl.action;
+    }
+
+    return payload.postback.payload;
+}
+
+module.exports = extractText;

package/src/transcript/htmlBodyFromTranscript.js

@@ -0,0 +1,21 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+/** @typedef {import('./transcriptFromHistory').Transcript} Transcript */
+
+/**
+ * @param {Transcript[]} transcript
+ * @param {string} [userSide]
+ * @param {string} [botSide]
+ * @returns {string}
+ */
+function htmlBodyFromTranscript (transcript, userSide = 'User', botSide = 'Bot') {
+
+    return transcript
+        .map((msg) => `<b>${msg.fromBot ? botSide : userSide}:</b> ${msg.text}`)
+        .join('<br />');
+}
+
+module.exports = htmlBodyFromTranscript;

package/src/transcript/textBodyFromTranscript.js

@@ -0,0 +1,21 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+/** @typedef {import('./transcriptFromHistory').Transcript} Transcript */
+
+/**
+ * @param {Transcript[]} transcript
+ * @param {string} [userSide]
+ * @param {string} [botSide]
+ * @returns {string}
+ */
+function textBodyFromTranscript (transcript, userSide = 'User', botSide = 'Bot') {
+
+    return transcript
+        .map((msg, i) => `${msg.fromBot ? '  <' : `${i > 0 ? '\n' : ''}# >`} ${msg.fromBot ? botSide : userSide}: ${msg.text}`)
+        .join('\n');
+}
+
+module.exports = textBodyFromTranscript;

package/src/transcript/transcriptFromHistory.js

@@ -0,0 +1,52 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+const extractText = require('./extractText');
+
+/**
+ * @callback GetInteractions
+ * @param {string} senderId
+ * @param {string} pageId
+ * @param {number} limit
+ * @returns {Promise<object[]>}
+ */
+
+/**
+ * @typedef {object} IChatStorage
+ * @prop {GetInteractions} getInteractions
+ */
+
+/**
+ * @typedef {object} Transcript
+ * @prop {string} text
+ * @prop {boolean} fromBot
+ */
+
+/**
+ *
+ * @param {IChatStorage} chatLogStorage
+ * @param {string} senderId
+ * @param {string} pageId
+ * @param {number} limit
+ * @returns {Promise<Transcript[]>}
+ */
+async function transcriptFromHistory (chatLogStorage, senderId, pageId, limit = 20) {
+    const data = await chatLogStorage.getInteractions(senderId, pageId, limit);
+
+    return data
+        .map((turn) => {
+            const { request, responses = [] } = turn;
+
+            return [
+                { fromBot: false, text: extractText(request) },
+                ...responses
+                    .map((response) => ({ fromBot: true, text: extractText(response) }))
+            ];
+        })
+        .reduce((ret, arr) => [...ret, ...arr], [])
+        .filter((ret) => !!ret.text);
+}
+
+module.exports = transcriptFromHistory;