wingbot 3.68.17 → 3.69.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.68.17",
+  "version": "3.69.0",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "type": "commonjs",

package/src/Request.js

@@ -1541,7 +1541,8 @@ It looks like the bot isn't connected to class BotApp or the Processor is used w
         campaign,
         timestamp = makeTimestamp(),
         data = null,
-        taskId = null
+        taskId = null,
+        setState = null
     ) {
         const postback = Request.postBack(
             senderId,
@@ -1551,6 +1552,11 @@ It looks like the bot isn't connected to class BotApp or the Processor is used w
             {},
             timestamp
         );
+
+        if (setState) {
+            Object.assign(postback.postback.payload, { setState });
+        }
+
         return Object.assign(postback, {
             campaign,
             taskId

package/src/graphApi/conversationsApi.js

@@ -7,6 +7,7 @@ const apiAuthorizer = require('./apiAuthorizer');
 const { apiTextOutputFilter, mapObject, defaultMapperFactory } = require('../utils/deepMapTools');
 
 /** @typedef {import('../utils/deepMapTools').Mapper} Mapper */
+/** @typedef {import('../notifications/Notifications')} Notifications */
 
 /**
  * @typedef {object} ConversationsAPI
@@ -20,11 +21,6 @@ const { apiTextOutputFilter, mapObject, defaultMapperFactory } = require('../uti
  * @prop {Function} getState
  */
 
-/**
- * @typedef {object} Notifications
- * @prop {Function} getSubscribtions
- */
-
 /**
  * @typedef {object} ChatLogStorage
  * @prop {Function} getInteractions
@@ -92,6 +88,28 @@ function conversationsApi (
         return data;
     }
 
+    async function subscriptions () {
+        const { pageId, senderId } = this;
+
+        if (!notifications) {
+            return null;
+        }
+
+        if (typeof notifications.getSubscriptions === 'function') {
+            return notifications.getSubscriptions(senderId, pageId);
+        }
+
+        if (typeof notifications.getSubscribtions === 'function') {
+            const sups = await notifications.getSubscribtions(senderId, pageId);
+            return sups.map((s) => ({
+                tag: s,
+                meta: {}
+            }));
+        }
+
+        return null;
+    }
+
     async function subscribtions () {
         if (!notifications || typeof notifications.getSubscribtions !== 'function') {
             return null;
@@ -107,21 +125,24 @@ function conversationsApi (
             state: apiTextOutputFilter(d.state, options.stateTextFilter),
             lastInteraction: d.lastInteraction || (new Date(0)),
             history,
-            subscribtions
+            subscribtions,
+            subscriptions
         });
     } else if (options.mapper) {
         mapState = (d) => ({
             ...mapObject(d, defaultMapperFactory(options.mapper)),
             lastInteraction: d.lastInteraction || (new Date(0)),
             history,
-            subscribtions
+            subscribtions,
+            subscriptions
         });
     } else {
         mapState = (d) => ({
             ...d,
             lastInteraction: d.lastInteraction || (new Date(0)),
             history,
-            subscribtions
+            subscribtions,
+            subscriptions
         });
     }
 

package/src/graphApi/schema.gql

@@ -121,6 +121,11 @@ type UserInteraction {
     err: String
 }
 
+type Subscription {
+    tag: String!
+    meta: Any
+}
+
 type Conversation {
     senderId: String!
     pageId: String!
@@ -128,6 +133,7 @@ type Conversation {
     name: String
     state: Any!
     subscribtions: [String]
+    subscriptions: [Subscription!]
     history (
         limit: Int! = 10
         startTimestamp: Float
@@ -190,6 +196,14 @@ input CreateCampaignInput {
     condition: String
 }
 
+input SubscriptionData {
+    pageId: String!
+    senderId: String!
+    tags: [String!]!
+    remove: Boolean = false
+    meta: Any
+}
+
 input UpdateCampaignInput {
     name: String
     action: String
@@ -303,4 +317,7 @@ type Mutation {
 
     "subscribe users"
     subscribeUsers(pageId:String!, senderIds:[String!]!, tag: String): Boolean
+
+    "subscribe with metadata"
+    subscribeWithData (subscriptions: [SubscriptionData!]!): Boolean
 }

package/src/notifications/Notifications.js

@@ -104,25 +104,26 @@ const DEFAULT_CAMPAIGN_DATA = {
  */
 
 /**
- * @typedef {object} Subscription
- * @prop {string} senderId
- * @prop {string} pageId
- * @prop {string} [meta]
+ * @typedef {object} SenderSubscription
+ * @prop {string} tag
+ * @prop {object} meta
  */
 
 /**
- * @callback PreprocessSubscriptions
- * @param {Subscription[]} subscriptions
- * @param {string} pageId
- * @returns {Promise<Subscription[]>|Subscription[]}
+ * @typedef {object} Logger
+ * @prop {Function} log
+ * @prop {Function} error
  */
 
+/** @typedef {import('./api/notificationsApiFactory').NotificationsApiOptions} ApiOptions */
+
 /**
- * @callback PreprocessSubscribers
- * @param {string[]} senderIds
- * @param {string} pageId
- * @param {string} tag
- * @returns {Promise<string[]>|string[]} list of senderIds
+ * @typedef {object} NotificationsServiceOptions
+ * @prop {Logger} [log]
+ * @prop {number} [options.default24Clearance] - use this clearance to ensure delivery in 24h
+ * @prop {string} [options.allAudienceTag] - tag to mark all users
+ *
+ * @typedef {ApiOptions & NotificationsServiceOptions} NotificationsOptions
  */
 
 /**
@@ -139,12 +140,7 @@ class Notifications extends EventEmitter {
      * @memberof Notifications
      *
      * @param {NotificationsStorage} notificationStorage
-     * @param {object} options
-     * @param {console} [options.log] - logger
-     * @param {number} [options.default24Clearance] - use this clearance to ensure delivery in 24h
-     * @param {string} [options.allAudienceTag] - tag to mark all users
-     * @param {PreprocessSubscribers} [options.preprocessSubscribers] - preprocess senderIds import
-     * @param {PreprocessSubscriptions} [options.preprocessSubscriptions]
+     * @param {NotificationsOptions} options
      */
     constructor (notificationStorage = new NotificationsStorage(), options = {}) {
         super();
@@ -407,6 +403,18 @@ class Notifications extends EventEmitter {
         return this._storage.getSenderSubscribtions(senderId, pageId);
     }
 
+    /**
+     *
+     * Get user subscribtions
+     *
+     * @param {string} senderId
+     * @param {string} pageId
+     * @returns {Promise<SenderSubscription[]>}
+     */
+    async getSubscriptions (senderId, pageId) {
+        return this._storage.getSenderSubscriptions(senderId, pageId);
+    }
+
     async _preloadSubscribtions (req, res) {
         if (res.data._requestSubscribtions) {
             req.subscribtions = res.data._requestSubscribtions;
@@ -788,24 +796,38 @@ class Notifications extends EventEmitter {
 
         let queued = 0;
 
+        const campaignData = campaign.data || {};
+
         while (hasUsers) {
             const { data: targets, lastKey: key } = await this._storage
                 .getSubscribtions(include, exclude, this.limit, campaign.pageId, lastKey);
 
             lastKey = key;
 
-            const campaignTargets = targets.map((target) => ({
-                senderId: target.senderId,
-                pageId: target.pageId,
-                campaignId: campaign.id,
-                enqueue
-            }));
+            const campaignTargets = targets.map((target) => {
+                const data = include.length === 0
+                    ? campaignData
+                    : Object.assign(
+                        {},
+                        campaignData,
+                        // @ts-ignore
+                        ...include.map((t) => (target.meta && target.meta[t]) || {})
+                    );
+
+                return {
+                    senderId: target.senderId,
+                    pageId: target.pageId,
+                    campaignId: campaign.id,
+                    enqueue,
+                    data
+                };
+            });
 
             const actions = await this.pushTasksToQueue(campaignTargets);
 
             queued += actions.length;
 
-            hasUsers = targets.length > 0 && lastKey;
+            hasUsers = targets.length > 0 && !!lastKey;
         }
 
         return { queued };
@@ -910,7 +932,15 @@ class Notifications extends EventEmitter {
             return { status: 204 };
         }
 
-        const message = Request.campaignPostBack(task.senderId, campaign, ts, task.data, task.id);
+        const message = Request.campaignPostBack(
+            task.senderId,
+            campaign,
+            ts,
+            task.data,
+            task.id,
+            task.data
+        );
+
         let status;
         let mid;
 

package/src/notifications/NotificationsStorage.js

@@ -6,26 +6,28 @@
 const uuid = require('uuid');
 
 /**
- * @typedef Tag {Object}
+ * @typedef {object} Tag
  * @prop {string} tag
  * @prop {number} subscribtions
  */
 
 /**
- * @typedef Target {Object}
+ * @typedef {object} Target
  * @prop {string} senderId
  * @prop {string} pageId
+ * @prop {{ [key: string]: object }} [meta]
  */
 
 /**
- * @typedef Subscribtion {Object}
+ * @typedef {object} Subscribtion
  * @prop {string} senderId
  * @prop {string} pageId
  * @prop {string[]} subs
+ * @prop {{ [key: string]: object }} [meta]
  */
 
 /**
- * @typedef Campaign {object}
+ * @typedef {object} Campaign
  * @prop {string} id
  * @prop {string} name
  *
@@ -63,7 +65,7 @@ const uuid = require('uuid');
  */
 
 /**
- * @typedef Task {Object}
+ * @typedef {object} Task
  * @prop {string} id
  * @prop {string} pageId
  * @prop {string} senderId
@@ -77,6 +79,21 @@ const uuid = require('uuid');
  * @prop {number} [leaved] - time the event was not sent because user left
  */
 
+/**
+ * @typedef {object} Subscription
+ * @prop {string} tag
+ * @prop {object} meta
+ */
+
+/**
+ * @typedef {object} SubscriptionData
+ * @prop {string} pageId
+ * @prop {string} senderId
+ * @prop {string[]} tags
+ * @prop {boolean} [remove]
+ * @prop {{ [key: string]: object }} [meta]
+ */
+
 const MAX_TS = 9999999999999;
 
 class NotificationsStorage {
@@ -450,9 +467,9 @@ class NotificationsStorage {
      * @param {string} senderId
      * @param {string} pageId
      * @param {string} tag
-     * @returns {Promise}
+     * @param {{}} [meta={}]
      */
-    _subscribe (senderId, pageId, tag) {
+    _subscribe (senderId, pageId, tag, meta = {}) {
         const key = `${senderId}|${pageId}`;
         let subscribtion = this._subscribtions.get(key);
         if (!subscribtion) {
@@ -463,20 +480,60 @@ class NotificationsStorage {
             };
         }
         if (!subscribtion.subs.includes(tag)) {
-            subscribtion = { ...subscribtion, subs: [...subscribtion.subs, tag] };
+            subscribtion = {
+                ...subscribtion,
+                subs: [...subscribtion.subs, tag]
+            };
+            if (meta && Object.keys(meta).length) {
+                Object.assign(subscribtion, {
+                    meta: {
+                        ...subscribtion.meta,
+                        [tag]: meta
+                    }
+                });
+            } else if (subscribtion.meta && subscribtion.meta[tag]) {
+                delete subscribtion.meta;
+            }
         }
 
         this._subscribtions.set(key, subscribtion);
     }
 
+    /**
+     *
+     * @param {SubscriptionData[]} subscriptionData
+     * @param {boolean} [onlyToKnown]
+     * @returns {Promise}
+     */
+    // eslint-disable-next-line no-unused-vars
+    async batchSubscribe (subscriptionData, onlyToKnown = null) {
+        subscriptionData.forEach(({
+            senderId, pageId, tags, remove = false, meta = {}
+        }) => {
+            if (remove) {
+                tags.forEach((tag) => {
+                    this._unsubscribe(senderId, pageId, tag);
+                });
+            } else {
+                tags.forEach((tag) => {
+                    this._subscribe(senderId, pageId, tag, meta[tag]);
+                });
+            }
+        });
+
+        return Promise.resolve();
+    }
+
     /**
      *
      * @param {string|string[]} senderId
      * @param {string} pageId
      * @param {string} tag
+     * @param {boolean} [onlyToKnown]
      * @returns {Promise}
      */
-    subscribe (senderId, pageId, tag) {
+    // eslint-disable-next-line no-unused-vars
+    subscribe (senderId, pageId, tag, onlyToKnown = null) {
         const insert = Array.isArray(senderId) ? senderId : [senderId];
         insert.forEach((sender) => this._subscribe(sender, pageId, tag));
         return Promise.resolve();
@@ -490,9 +547,14 @@ class NotificationsStorage {
      * @returns {Promise<string[]>}
      */
     unsubscribe (senderId, pageId, tag = null) {
+        const unsubscribtions = this._unsubscribe(senderId, pageId, tag);
+        return Promise.resolve(unsubscribtions);
+    }
+
+    _unsubscribe (senderId, pageId, tag = null) {
         const key = `${senderId}|${pageId}`;
         if (!this._subscribtions.has(key)) {
-            return Promise.resolve([]);
+            return [];
         }
         const unsubscribtions = [];
         let subscribtion = this._subscribtions.get(key);
@@ -507,12 +569,15 @@ class NotificationsStorage {
                     return !out;
                 })
         };
+        if ('meta' in subscribtion && subscribtion.meta[tag]) {
+            delete subscribtion.meta[tag];
+        }
         if (subscribtion.subs.length === 0) {
             this._subscribtions.delete(key);
         } else {
             this._subscribtions.set(key, subscribtion);
         }
-        return Promise.resolve(unsubscribtions);
+        return unsubscribtions;
     }
 
     /**
@@ -581,7 +646,8 @@ class NotificationsStorage {
 
         const data = ret.map((sub) => ({
             senderId: sub.senderId,
-            pageId: sub.pageId
+            pageId: sub.pageId,
+            ...(sub.meta ? { meta: sub.meta } : {})
         }));
 
         let nextLastKey = null;
@@ -598,12 +664,11 @@ class NotificationsStorage {
     }
 
     /**
-     *
      * @param {string} senderId
      * @param {string} pageId
-     * @returns {Promise<string[]>}
+     * @returns {Promise<Subscription[]>}
      */
-    getSenderSubscribtions (senderId, pageId) {
+    async getSenderSubscriptions (senderId, pageId) {
         const key = `${senderId}|${pageId}`;
 
         if (!this._subscribtions.has(key)) {
@@ -612,7 +677,21 @@ class NotificationsStorage {
 
         const sub = this._subscribtions.get(key);
 
-        return Promise.resolve(sub.subs);
+        return sub.subs.map((tag) => ({
+            tag,
+            meta: (sub.meta && sub.meta[tag]) || {}
+        }));
+    }
+
+    /**
+     *
+     * @param {string} senderId
+     * @param {string} pageId
+     * @returns {Promise<string[]>}
+     */
+    async getSenderSubscribtions (senderId, pageId) {
+        const subs = await this.getSenderSubscriptions(senderId, pageId);
+        return subs.map((s) => s.tag);
     }
 
     /**

package/src/notifications/api/notificationsApiFactory.js

@@ -5,6 +5,9 @@
 
 const apiAuthorizer = require('../../graphApi/apiAuthorizer');
 
+/** @typedef {import('../NotificationsStorage')} NotificationsStorage */
+/** @typedef {import('../Notifications')} Notifications */
+
 /**
  *
  * @param {*} info
@@ -38,6 +41,59 @@ function getFields (info) {
     }, {});
 }
 
+/**
+ * @typedef {object} Target
+ * @prop {string} senderId
+ * @prop {string} pageId
+ */
+
+/**
+ * @typedef {object} SubscriptionData
+ * @prop {string} pageId
+ * @prop {string} senderId
+ * @prop {string[]} tags
+ * @prop {boolean} [remove]
+ * @prop {{ [key: string]: object }} [meta]
+ */
+
+/**
+ *
+ * @callback PreprocessSubscribe
+ * @param {SubscriptionData[]} subscriptions
+ * @returns {Promise<SubscriptionData[]>}
+ */
+
+/**
+ *
+ * @callback PreprocessSubscriptions
+ * @param {Target[]} subscriptions
+ * @param {string} [pageId]
+ * @returns {Promise<Target[]>|Target[]}
+ */
+
+/**
+ *
+ * @callback PreprocessSubscribers
+ * @param {string[]} senderIds
+ * @param {string} pageId
+ * @param {string} tag
+ * @returns {Promise<string[]>|string[]}
+ */
+
+/**
+ * @typedef {object} NotificationsApiOptions
+ * @prop {PreprocessSubscribe} [preprocessSubscribe]
+ * @prop {PreprocessSubscriptions} [preprocessSubscriptions]
+ * @prop {PreprocessSubscribers} [preprocessSubscribers]
+ */
+
+/**
+ *
+ * @param {NotificationsStorage} storage
+ * @param {Notifications} notifications
+ * @param {*} acl
+ * @param {NotificationsApiOptions} options
+ */
 function notificationsApiFactory (storage, notifications, acl, options = {}) {
     return {
         async campaigns (args, ctx) {
@@ -213,6 +269,32 @@ function notificationsApiFactory (storage, notifications, acl, options = {}) {
             return true;
         },
 
+        /**
+         * @typedef {object} SubscriptionData
+         * @prop {string} pageId
+         * @prop {string} senderId
+         * @prop {string[]} tags
+         * @prop {boolean} [remove]
+         * @prop {{ [key: string]: object }} [meta]
+         */
+
+        /**
+         *
+         * @param {{ subscriptions: SubscriptionData[] }} args
+         * @param {*} ctx
+         * @returns {Promise<boolean>}
+         */
+        async subscribeWithData (args, ctx) {
+            if (!apiAuthorizer(args, ctx, acl)) {
+                return null;
+            }
+
+            const { subscriptions } = args;
+
+            await storage.batchSubscribe(subscriptions, true);
+            return true;
+        },
+
         async tags (args, ctx) {
             if (!apiAuthorizer(args, ctx, acl)) {
                 return null;

package/src/wingbot/CustomEntityDetectionModel.js

@@ -304,13 +304,14 @@ class CustomEntityDetectionModel {
             return zLen - aLen;
         });
 
+        if (this._options.verbose) this._log.log('#NLP [nonOverlapping]', { entities, expectedEntities, justDuplicates });
+
         let res = [];
 
         for (let i = 0; i < entities.length; i++) {
             const entity = entities[i];
 
             const isExpected = expectedEntities.includes(entity.entity);
-
             const duplicate = res
                 .find((e) => e.start === entity.start && e.end === entity.end);
 
@@ -353,6 +354,10 @@ class CustomEntityDetectionModel {
                         const othersConflict = res.some((e) => putback === e
                             || (e.start < putback.end && e.end > putback.start));
 
+                        this._log.log(`#NLP (${i}|${k} [putBack: ${entity.entity}|${putback.entity}] (${i}|${k})`, {
+                            putback, entity, currentConflict, othersConflict
+                        });
+
                         if (!currentConflict && !othersConflict) {
                             res.push(putback);
                         }
@@ -360,6 +365,12 @@ class CustomEntityDetectionModel {
                 }
             }
 
+            if (this._options.verbose) {
+                this._log.log(`#NLP (${i}) [nonOverlapping| ${entity.entity}:${entity.value}]`, {
+                    willRemoveEntity: overlapping, overlapping, duplicate, isExpected, entity
+                });
+            }
+
             if (!overlapping) {
                 res.push(entity);
             }

package/src/wingbot/WingbotModel.js

@@ -102,7 +102,7 @@ class WingbotModel extends CachedModel {
             `matches=${encodeURIComponent(this._matches)}`
         ];
 
-        if (this._options.verbose) this._log.log(`#NLP: "${text}" [query]`, { matches: this._matches, localEntities: entities });
+        if (this._options.verbose) this._log.log(`#NLP: ${text} [query]`, { matches: this._matches, localEntities: entities });
 
         if (entities) {
             const buf = await this._brotli(Buffer.from(JSON.stringify({ entities })));
@@ -123,7 +123,7 @@ class WingbotModel extends CachedModel {
 
             const response = await res.json();
 
-            if (this._options.verbose) this._log.log(`#NLP: ${text} [response]`, { response });
+            if (this._options.verbose) this._log.log(`#NLP: ${text} [response]`, response);
 
             if (res.status >= 300) {
                 this._log.warn(`AI query failed: ${response.message || res.statusText}`);