chat-platform 1.3.2 → 2.0.0

package/__tests__/universal-platform.js

@@ -82,57 +82,48 @@ describe('Universal Connector', () => {
         resolve(message);
       })
     );
-    // store the global resolver
-    chatServer.onGetChatIdFromUserId((userId, transport, message) => {
-      if (userId === '1234' && transport === 'universal') {
-        return '42';
-      } else if (userId === '1234' && transport === 'universal-alt') {
-        return '43';
+  });
+
+
+  it('send outgoing message', async () => {
+    await chatServer.start()
+    const message = await chatServer.createMessage('42', '1234', '4567', {
+      payload: {
+        type: 'a-message-type',
+        chatId: '42'
       }
-      return null;
     });
-  });
+    let sentMessage = await chatServer.send(message);
+
+    assert.equal(sentMessage.message_id, '444');
+    expect(sendFunction).to.have.been.called();
 
-  it('receive incoming message', () => {
-    chatServer.start()
-      .then(() => {
-        chatServer.on('message', message => {
-          assert.equal(message.payload.type, 'message');
-          assert.equal(message.custom_value, 42);
-          assert.equal(message.payload.chatId, '42');
-          assert.equal(message.originalMessage.messageId, 'xyz');
-          assert.equal(message.originalMessage.userId, 24);
-          assert.isFunction(message.chat);
-          const variables = message.chat().all();
-          assert.equal(variables.payload, 'Bazinga');
-          assert.equal(variables.transport, 'universal');
-          assert.equal(variables.authorized, false);
-          assert.equal(variables.language, 'it');
-          assert.instanceOf(message.payload.ts, moment);
-        });
-        chatServer.receive({
-          text: 'Bazinga',
-          lang: 'it',
-          chat_id: '42',
-          _id: 'xyz',
-          user: { id: 24 }
-        });
-      });
   });
 
-  it('send outgoing message', () => {
-    return chatServer.start()
-      .then(() => chatServer.createMessage('42', '1234', '4567', {
-        payload: {
-          type: 'a-message-type',
-          chatId: '42'
-        }
-      }))
-      .then(message => chatServer.send(message))
-      .then(message => {
-        assert.equal(message.message_id, '444');
-        expect(sendFunction).to.have.been.called();
-      });
+  it('receive incoming message', async (done) => {
+    await chatServer.start()
+
+    chatServer.on('message', message => {
+      assert.equal(message.payload.type, 'message');
+      assert.equal(message.custom_value, 42);
+      assert.equal(message.payload.chatId, '42');
+      assert.equal(message.originalMessage.messageId, 'xyz');
+      assert.equal(message.originalMessage.userId, 42);
+      assert.isFunction(message.chat);
+      const variables = message.chat().all();
+      assert.equal(variables.payload, 'Bazinga');
+      assert.equal(variables.authorized, false);
+      assert.equal(variables.language, 'it');
+      assert.instanceOf(message.payload.ts, moment);
+      done();
+    });
+    chatServer.receive({
+      text: 'Bazinga',
+      lang: 'it',
+      chat_id: '42',
+      _id: 'xyz',
+      user: { id: 24 }
+    });
   });
 
   it('send outgoing message wrong type', () => {
@@ -147,44 +138,4 @@ describe('Universal Connector', () => {
       .then(() => expect(sendFunction).to.not.have.been.called());
   });
 
-  it('create a message with just a userId and resolves it', () => {
-    return chatServer.start()
-      .then(() => chatServer.createMessage(null, '1234', '4567', {
-        payload: {
-          type: 'a-message-type'
-        }
-      }))
-      .then(message => chatServer.send(message))
-      .then(() => expect(sendFunction).to.have.been.called());
-  });
-
-  it('create a message with just a userId and doesn\'t resolve it', () => {
-    return chatServer.start()
-      .then(() => chatServer.createMessage(null, '5678', '4567', {
-        payload: {
-          type: 'a-message-type'
-        }
-      }))
-      .then(message => chatServer.send(message))
-      .then(
-        () => {},
-        e => {
-          assert.include(e.toString(), 'Error: The userId<->chatId resolver was not able to find a valid chatId for user 5678');
-          expect(sendFunction).to.not.have.been.called()
-        }
-      );
-  });
-
-  it('create a message with a server and just a userId and try to send to the other server', () => {
-    return chatServer.start()
-      .then(() => chatServer.createMessage(null, '1234', '4567', {
-        payload: {
-          type: 'a-message-type'
-        }
-      }))
-      .then(message => chatServerAlt.send(message))
-      .then(() => expect(sendFunctionAlt).to.have.been.called());
-  });
-
-
 });

package/chat-platform.js

@@ -2,7 +2,7 @@ const _ = require('underscore');
 const _s = require('underscore.string');
 const clc = require('cli-color');
 const prettyjson = require('prettyjson');
-const { isEmpty, when } = require('./lib/utils');
+const { when } = require('./lib/utils');
 const EventEmitter = require('events').EventEmitter;
 const inherits = require('util').inherits;
 const lcd = require('./helpers/lcd');
@@ -96,8 +96,9 @@ const ChatExpress = function(options) {
     }
   }
 
-  function parseMessage(payload, options, chatServer) {
-    var instanceOptions = chatServer.getOptions();
+  async function parseMessage(payload, options, chatServer) {
+    const instanceOptions = chatServer.getOptions();
+    const { contextProvider, transport } = instanceOptions;
 
     payload = _.clone(payload);
     // sets inbound
@@ -111,21 +112,34 @@ const ChatExpress = function(options) {
     }
 
     evaluateParam(payload, 'chatId', 'chatIdKey', chatServer);
-    evaluateParam(payload, 'userId', 'userIdKey', chatServer);
     evaluateParam(payload, 'messageId', 'messageIdKey', chatServer);
     evaluateParam(payload, 'ts', 'tsKey', chatServer);
     evaluateParam(payload, 'type', 'type', chatServer);
     evaluateParam(payload, 'language', 'language', chatServer);
-    // default userId on chatId, never leave it blank, pay attention
-    // on removing this constraint (some chat context may be lost)
-    payload.userId = !_.isEmpty(payload.userId) ? payload.userId : payload.chatId;
+    evaluateParam(payload, 'userId', 'userIdKey', chatServer);
+
     // evaluate callbacks
     const callbacks = chatServer.getCallbacks();
-    _(['chatId', 'userId', 'ts', 'type', 'language', 'messageId']).each(function(callbackName) {
+    _(['chatId', 'ts', 'type', 'language', 'messageId']).each(function(callbackName) {
       if (_.isFunction(callbacks[callbackName])) {
         payload[callbackName] = callbacks[callbackName].call(chatServer, payload)
       }
     });
+
+    // try to evaluate a default userId
+    let defaultUserId = payload.userId;
+    if (_.isEmpty(defaultUserId) && _.isFunction(callbacks['userId'])) {
+      defaultUserId = callbacks['userId'].call(chatServer, payload);
+    }
+
+    // get the userId from chatId, ask the context provider to create one and to create
+    // the bindings between chatId <-> transport <-> userId
+    payload.userId = await contextProvider.getOrCreateUserId(
+      String(payload.chatId),
+      transport,
+      defaultUserId
+    );
+
     // at this point should have at least the values chatId and type
     if (payload.chatId == null && !options.relaxChatId) {
       throw 'Error: inbound message key "chatId" for transport ' + _this.options.transport + ' is empty\n\n'
@@ -166,11 +180,30 @@ const ChatExpress = function(options) {
     const onCreateMessage = _.isFunction(options.onCreateMessage) ? options.onCreateMessage : identity;
     inboudMessage = inboudMessage || {};
 
-    const chatContext = await when(contextProvider.getOrCreate(chatId, userId, {
-      chatId: chatId,
-      userId: userId,
+    if (_.isEmpty(userId) && _.isEmpty(chatId)) {
+      throw 'Both userId and chatId empty, cannot start a conversation';
+    }
+    // get the context finding the userId given chatId, chatbotId and transport
+    if (_.isEmpty(userId) && !_.isEmpty(chatId)) {
+      userId = await contextProvider.getUserId(chatId, options.transport);
+      if (_.isEmpty(userId)) {
+        throw `Unable to resolve userId from chatId "${chatId}" (${options.transport})`;
+      }
+    }
+    if (_.isEmpty(chatId) && !_.isEmpty(userId)) {
+      chatId = await contextProvider.getChatId(userId, options.transport);
+      if (_.isEmpty(chatId)) {
+        throw `Unable to resolve chatId from userId "${userId}" (${options.transport}). That means either the userId "${userId}" doesn't exist or it's not possible to find a valid chatId for the platform ${options.transport}.`;
+      }
+    }
+
+    const chatContext = await contextProvider.getOrCreateContext(userId, {
+      chatId,
+      userId,
       transport: options.transport,
-      }));
+      chatbotId: options.chatbotId
+    });
+
     await chatContext.set({
       authorized: false,
       pending: false,
@@ -180,13 +213,13 @@ const ChatExpress = function(options) {
       originalMessage: {
         chatId: chatId,
         userId: userId,
+        chatbotId: options.chatbotId,
         messageId: messageId,
         transport: options.transport,
         language: null
       },
       chat() {
-        return contextProvider.get(
-          chatId,
+        return contextProvider.getContext(
           userId,
           {
             userId: this.originalMessage.userId,
@@ -214,7 +247,7 @@ const ChatExpress = function(options) {
     return onCreateMessage.call(chatServer, message);
   }
 
-  function inboundMessage(payload, chatServer) {
+  async function inboundMessage(payload, chatServer) {
     const options = chatServer.getOptions();
     const contextProvider = options.contextProvider;
     if (chatServer.isDebug()) {
@@ -233,7 +266,7 @@ const ChatExpress = function(options) {
     // parse the message to extract the minimum payload needed for chat-platform to work properly
     // could raise errors, relay to chat server
     try {
-      var parsedMessage = parseMessage(payload, _this.options, chatServer);
+      var parsedMessage = await parseMessage(payload, _this.options, chatServer);
     } catch(e) {
       chatServer.emit('error', e);
       return;
@@ -258,10 +291,13 @@ const ChatExpress = function(options) {
         inbound: true
       },
       chat: function() {
-        return contextProvider.get(
-          parsedMessage.chatId,
+        return contextProvider.getContext(
           parsedMessage.userId,
-          { userId: this.originalMessage.userId, transport: this.originalMessage.transport, chatId: this.originalMessage.chatId }
+          {
+            userId: this.originalMessage.userId,
+            transport: this.originalMessage.transport,
+            chatId: this.originalMessage.chatId
+          }
         );
       },
       api: function() {
@@ -281,15 +317,20 @@ const ChatExpress = function(options) {
     // if any context provider, then create the context
     if (contextProvider != null) {
       stack = stack
-        .then(() => when(contextProvider.getOrCreate(
-          parsedMessage.chatId,
+        .then(() => contextProvider.getOrCreateContext(
           parsedMessage.userId,
-          { userId: parsedMessage.userId, transport: parsedMessage.transport, chatId: parsedMessage.chatId }
-        )))
-        .then(chatContext => when(chatContext.set({ language: parsedMessage.language, authorized: false, pending: false })))
-        .then(function() {
-          return when(message);
-        });
+          {
+            userId: parsedMessage.userId,
+            transport: parsedMessage.transport,
+            chatId: parsedMessage.chatId
+          }
+        ))
+        .then(chatContext => when(chatContext.set({
+          language: parsedMessage.language,
+          authorized: false,
+          pending: false
+        })))
+        .then(() => when(message));
     } else {
       // eslint-disable-next-line no-console
       console.log(yellow('WARNING: context provider was not specified'));
@@ -406,18 +447,6 @@ const ChatExpress = function(options) {
       return;
     }
 
-    const instanceOptions = chatServer.getOptions();
-    // check if the message is from the right platform (in static class or instance)
-    /*if (message.originalMessage != null && message.originalMessage.transport !== _this.options.transport &&
-      message.originalMessage.transport !== instanceOptions.transport) {
-      // exit, it's not from the current platform
-      if (chatServer.isDebug()) {
-        // eslint-disable-next-line no-console
-        console.log(yellow('Skipped incoming message for platform: ' + message.originalMessage.transport));
-      }
-      return;
-    }*/
-
     if (chatServer.isDebug()) {
       // eslint-disable-next-line no-console
       console.log(orange('-- OUTBOUND MESSAGE --'));
@@ -429,56 +458,7 @@ const ChatExpress = function(options) {
 
     // create empty promise
     let stack = new Promise(resolve => resolve(message));
-    // check for chatId, if not present check for userId-chatId translator, otherwise fail
-    stack = stack.then(message => {
-      const { transport } = instanceOptions;
-      if (!isEmpty(message.payload.chatId)) {
-        // if there's a chatId, everything ok, skip
-        return message;
-      } else if (_.isFunction(_globalCallbacks.getChatIdFromUserId) && message.originalMessage.userId != null) {
-        // try to call the callback
-        try {
-          return when(_globalCallbacks.getChatIdFromUserId.call(chatServer, message.originalMessage.userId, transport, message))
-            .then(
-              chatId => {
-                if (isEmpty(chatId)) {
-                  // eslint-disable-next-line no-console
-                  console.log(lcd.error(`[onGetChatIdFromUserId] The userId<->chatId resolver was not able to find a valid chatId for user ${message.originalMessage.userId}(${transport})`));
-                  throw new Error(`The userId<->chatId resolver was not able to find a valid chatId for user ${message.originalMessage.userId}(${transport})`);
-                } else {
-                  if (instanceOptions.debug) {
-                    // eslint-disable-next-line no-console
-                    console.log(lcd.green('[onGetChatIdFromUserId]') + lcd.grey(` Resolved ${message.originalMessage.userId}(${transport}) in chatId:${chatId}`));
-                  }
-                  message.payload.chatId = chatId;
-                  return message;
-                }
-              }
-            );
-        } catch(e) {
-          // eslint-disable-next-line no-console
-          console.log(lcd.error(`[onGetChatIdFromUserId] runtime error in chatId<->userId resolver for user ${message.originalMessage.userId}(${transport})`));
-          lcd.dump(e);
-          throw new Error(`[onGetChatIdFromUserId] runtime error in chatId<->userId resolver for user ${message.originalMessage.userId}(${transport})`);
-        }
-      } else {
-        // provide some feedback for not being able to resolve a chatId
-        if (instanceOptions.debug) {
-          if (_.isFunction(_globalCallbacks.getChatIdFromUserId) && isEmpty(message.originalMessage.userId)) {
-            // eslint-disable-next-line no-console
-            console.log(lcd.warn(`[onGetChatIdFromUserId] Callback was provided but incoming message has no userId (${transport}), unable to resolve a valid chatId`));
-          } else if (!_.isFunction(_globalCallbacks.getChatIdFromUserId)) {
-            // eslint-disable-next-line no-console
-            console.log(lcd.warn('[onGetChatIdFromUserId] Callback was NOT provided and chatId is empty'));
-          }
-        }
-        // raise error only if not relaxChatId
-        if (!instanceOptions.relaxChatId) {
-          throw new Error('Incoming message has empty chatId and no chatId - userId resolved has been provided');
-        }
-      }
-      return message;
-    });
+
     // run general middleware
     _(_this.uses.concat(chatServer.getUseMiddleWares())).each(function(filter) {
       stack = stack.then(function(message) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chat-platform",
-  "version": "1.3.2",
+  "version": "2.0.0",
   "description": "Universal Chat Platform",
   "main": "index.js",
   "scripts": {
@@ -19,14 +19,15 @@
     "prettyjson": "^1.2.1",
     "request": "^2.88.0",
     "sequelize": "^5.21.6",
-    "sqlite3": "^4.1.1",
+    "sqlite3": "^5.0.0",
     "underscore": "^1.9.1",
     "underscore.string": "^3.3.5"
   },
   "devDependencies": {
     "chai": "^4.1.1",
     "chai-spies": "^1.0.0",
-    "eslint": "^4.12.1",
+    "eslint": "^8.12.0",
+    "eslint-plugin-jest": "^26.1.3",
     "jest": "^22.0.6"
   }
 }

package/providers/memory.js

@@ -1,11 +1,13 @@
 const _ = require('underscore');
-const _store = {};
-const _storeUserIds = {};
 
 const isEmpty = value => value == null || value === '';
 
-function MemoryStore(chatId, userId, statics = {}, warnings = false) {
-  this.chatId = chatId != null ? String(chatId) : null;
+const _storeChatIds = {};
+const _storeUserIds = {};
+const _store = {};
+
+function MemoryStore(userId, statics = {}, warnings = false) {
+  //this.chatId = chatId != null ? String(chatId) : null;
   this.userId = userId != null ? String(userId) : null;
   // make sure userId is always a string
   this.statics = Object.assign({}, statics, { userId: statics.userId != null ? String(statics.userId) : undefined  });
@@ -14,19 +16,15 @@ function MemoryStore(chatId, userId, statics = {}, warnings = false) {
   }
   return this;
 }
+
 _.extend(MemoryStore.prototype, {
   getPayload() {
     // always precedence to userId
     if (this.userId != null && _storeUserIds[this.userId] != null) {
       return _storeUserIds[this.userId];
-    } else if (this.chatId != null && _store[this.chatId] != null) {
-      return _store[this.chatId];
     } else if (this.userId != null) {
       _storeUserIds[this.userId] = {};
       return _storeUserIds[this.userId];
-    } else if (this.chatId != null) {
-      _store[this.chatId] = {};
-      return _store[this.chatId];
     }
     return {};
   },
@@ -105,32 +103,74 @@ _.extend(MemoryStore.prototype, {
 
 function MemoryFactory() {
 
+  this.getOrCreateUserId = async function(chatId, transport, defaultUserId) {
+    // try to find a userId given then chatId / transport for the current chatbot
+    if (isEmpty(chatId)) {
+      return null;
+    }
+
+    if (_storeChatIds[transport] != null && !_.isEmpty(_storeChatIds[transport][chatId])) {
+      return _storeUserIds[transport][chatId];
+    } else {
+      const userId = !_.isEmpty(defaultUserId) ? defaultUserId : chatId;
+      _storeUserIds[chatId] = _storeUserIds[chatId] != null ? _storeUserIds[chatId] : {};
+      _storeUserIds[chatId][transport] = userId;
+      _storeChatIds[userId] = _storeChatIds[userId] != null ? _storeChatIds[userId] : {};
+      _storeChatIds[userId][transport] = chatId;
+      return userId;
+    }
+  };
+
+  this.getUserId = async function(chatId, transport) {
+    return _storeUserIds[chatId] != null && !_.isEmpty(_storeUserIds[chatId][transport]) ?
+      _storeUserIds[chatId][transport] : chatId;
+  };
+
+  this.getChatId = async function(userId, transport) {
+    return _storeChatIds[userId] != null && !_.isEmpty(_storeChatIds[userId][transport]) ?
+      _storeChatIds[userId][transport] : null;
+  };
+
+  this.getOrCreateContext = async function(userId, statics) {
+    if (isEmpty(userId)) {
+      return null;
+    }
+    return new MemoryStore(userId, { ...statics });
+  };
+
+  this.mergeUserId = async function(fromUserId, toUserId) {
+    const destination = _storeChatIds[toUserId];
+    const source = _storeChatIds[fromUserId];
+
+    Object.keys(source)
+      .forEach(transport => {
+        const chatId = source[transport];
+        // copy chatId/transport to destination if doesn't exist
+        if (destination[transport] == null) {
+          destination[transport] = chatId;
+        }
+        // replace chatId reference
+        _storeUserIds[chatId][transport] = toUserId;
+      });
+
+    delete _storeChatIds[fromUserId];
+  };
+  this.getContext = function(userId, statics) {
+    return new MemoryStore(userId, { ...statics });
+  };
+
   this.getOrCreate = function(chatId, userId, statics) {
+    console.log('getOrCreate() is deprecated, use getOrCreateContext() instead');
     if (isEmpty(chatId) && isEmpty(userId)) {
       return null;
     }
     // just create an class that just wraps chatId and userId, add static value (cline)
-    const store = new MemoryStore(chatId, userId, { ...statics });
+    const store = new MemoryStore(userId, { ...statics });
     return store;
-    /*const chatContext = this.get(chatId, userId);
-    if (chatContext == null) {
-      const memoryStore = new MemoryStore({ ...defaults });
-      _store[chatId] = memoryStore;
-      if (!isEmpty(userId)) {
-        _storeUserIds[userId] = memoryStore;
-      }
-      return _store[chatId];
-    }
-    return chatContext;
-    */
   };
+
   this.get = function(chatId, userId, statics) {
-    /*if (!isEmpty(chatId) && _store[chatId] != null) {
-      return _store[chatId];
-    } else if (!isEmpty(userId) && _storeUserIds[userId] != null) {
-      return _storeUserIds[userId];
-    }
-    return null;*/
+    console.log('get() is deprecated');
     return new MemoryStore(chatId, userId, { ...statics });
   };
 
@@ -145,13 +185,13 @@ _.extend(MemoryFactory.prototype, {
   getOrCreate: function(/*chatId, userId, statics*/) {
   },
   assignToUser(userId, context) {
-    // when merging a user into another, this trasnfer the current context to another user
-    // TODO perhaps remove other occurence
+    console.log('assignToUser() is deprecated')
     _storeUserIds[userId] = context;
   },
   reset() {
     Object.keys(_store).forEach(key => delete _store[key]);
     Object.keys(_storeUserIds).forEach(key => delete _storeUserIds[key]);
+    Object.keys(_storeChatIds).forEach(key => delete _storeUserIds[key]);
     return this;
   },
   stop: function() {

package/providers/plain-file.js

@@ -2,12 +2,11 @@ const _ = require('underscore');
 const fs = require('fs');
 const moment = require('moment');
 const crypto = require('crypto');
+
 const lcd = require('../helpers/lcd');
 const FileQueue = require('../helpers/promises-queue');
 const filesQueue = {};
 
-// memory cache, each loaded store is here and it's saved to filesystem at every changes,
-// subsequent read hit the cache
 let _store = {};
 // main index
 let _index;
@@ -28,7 +27,6 @@ const parse = content => {
   return obj;
 };
 
-
 const deleteFile = file => {
   return new Promise((resolve, reject) => {
     fs.unlink(file, err => {
@@ -131,6 +129,37 @@ function FileFactory(params) {
     throw 'Plain file context provider: "path" (' + params.path + ') doesn\'t exist';
   }
 
+  this.getOrCreateUserId = async function(chatId, transport) {
+    return chatId;
+  };
+
+  this.getUserId = async function(chatId, transport) {
+    // plain file is actually not implemented for multi-transport, alwats use sqlite
+    return chatId;
+  };
+
+  this.getChatId = async function(userId, transport) {
+    return userId;
+  };
+
+  this.getOrCreateContext = async function(userId, statics) {
+    const { path } = params;
+    // chatId is always userId
+    return new FileStore(userId, userId, { ...statics }, { path });
+  };
+
+  this.mergeUserId = async function(fromUserId, toUserId) {
+    // not implemented
+  };
+
+  this.getContext = function(userId, statics) {
+    const { path } = params;
+    // chatId is always userId
+    return new FileStore(userId, userId, { ...statics }, { path });
+  };
+
+  // below here deprecated
+
   this.getOrCreate = function(chatId, userId = null, statics = {}) {
     const { path } = params;
     return new FileStore(chatId, userId, { ...statics }, { path });