chat-platform 1.3.2 → 2.0.0

package/providers/sqlite.js

@@ -10,16 +10,16 @@ const Op = Sequelize.Op;
 
 const isEmpty = value => value == null || value === '';
 
-
-
-
-function SQLiteStore(chatId, userId, statics = {}, warnings = false) {
-  this.chatId = chatId != null ? String(chatId) : null;
+function SQLiteStore(userId, chatbotId, statics = {}, warnings = false) {
   this.userId = userId != null ? String(userId) : null;
+  this.chatbotId = chatbotId;
   // make sure userId is always a string
   this.statics = Object.assign({}, statics, { userId: statics.userId != null ? String(statics.userId) : undefined  });
   if (warnings && _.isEmpty(statics)) {
-    console.trace('Warning: empty statics vars')
+    console.trace('Warning: empty statics vars');
+  }
+  if (warnings && _.isEmpty(chatbotId)) {
+    console.trace('Warning: empty chatbotId');
   }
   return this;
 }
@@ -30,6 +30,9 @@ function SQLiteFactory(params) {
   if (_.isEmpty(params.dbPath)) {
     throw 'SQLite context provider: missing parameter "dbPath"';
   }
+  if (_.isEmpty(params.chatbotId)) {
+    throw 'SQLite context provider: missing parameter "chatbotId"';
+  }
   if (!fs.existsSync(params.dbPath)) {
     //throw 'SQLite context provider: "dbPath" (' + params.path + ') doesn\'t exist';
     try {
@@ -39,6 +42,7 @@ function SQLiteFactory(params) {
       throw 'SQLite context provider: "dbPath" (' + params.path + ') doesn\'t exist and unable to create';
     }
   }
+  this.chatbotId = params.chatbotId;
 
   const sequelize = new Sequelize('mission_control', '', '', {
     host: 'localhost',
@@ -49,16 +53,28 @@ function SQLiteFactory(params) {
 
   const Context = sequelize.define('context', {
     userId: { type: Sequelize.STRING },
-    chatId: { type: Sequelize.STRING },
-    payload: { type: Sequelize.STRING }
+    payload: { type: Sequelize.STRING },
+    chatbotId: { type: Sequelize.STRING }
   }, {
     indexes: [
-      { name: 'chatid_userid', using: 'BTREE', fields: ['userId'] },
-      { name: 'chatid_chatid', using: 'BTREE', fields: ['chatId'] }
+      { name: 'context_userid', using: 'BTREE', fields: ['userId'] },
+      { name: 'context_chatbotId', using: 'BTREE', fields: ['chatbotId'] }
     ]
   });
 
-
+  const ChatId = sequelize.define('chatid', {
+    userId: { type: Sequelize.STRING, allowNull: false },
+    chatId: { type: Sequelize.STRING, allowNull: false },
+    transport: { type: Sequelize.STRING, allowNull: false },
+    chatbotId: { type: Sequelize.TEXT }
+  }, {
+    indexes: [
+      { name: 'chatid_userid', using: 'BTREE', fields: ['userId'] },
+      { name: 'chatid_chatid', using: 'BTREE', fields: ['chatId'] },
+      { name: 'chatid_transport', using: 'BTREE', fields: ['transport'] },
+      { name: 'chatid_chatbotId', using: 'BTREE', fields: ['chatbotId'] }
+    ]
+  });
 
   // **
   // Start definition if SQLite store, with closure I can spare passing a Context as configuration
@@ -97,30 +113,14 @@ function SQLiteFactory(params) {
     },
 
     async getPayload() {
-      // get payload using chatId or userId
-      const contexts = await Context.findAll({ where: {
-        [Op.or]: [
-          { chatId: this.chatId },
-          { userId: this.userId }
-        ]
+      // get payload using userId (it generally defaults to chatId)
+      const context = await Context.findOne({ where: {
+        userId: this.userId,
+        chatbotId: this.chatbotId
       }});
-      let payload;
-      let context;
-      if (contexts.length === 0) {
-        // if not present then create the row
-        context = await Context.create({ payload: JSON.stringify({}), chatId: this.chatId, userId: this.userId });
-        payload = {};
-      } else {
-        // if by any change there are two matched rows, one for the chatId and one for userId
-        // always prefer the userId (that could happen if the user star using the sqlite provider) as
-        // is and at some point the MC_store assign the context to the user
-        context = contexts.find(context => context.userId === this.userId);
-        if (context == null) {
-          context = contexts.find(context => context.chatId === this.chatId);
-        }
-        if (context == null) {
-          context = contexts[0];
-        }
+
+      if (context != null) {
+        let payload;
         // finally decode
         try {
           payload = JSON.parse(context.payload);
@@ -128,8 +128,16 @@ function SQLiteFactory(params) {
           // default if error
           payload = {};
         }
+        return { payload, id: context.id };
+      } else {
+        // if not present then create the row
+        const context = await Context.create({
+          payload: JSON.stringify({}),
+          chatbotId: this.chatbotId,
+          userId: this.userId
+        });
+        return { payload: {}, id: context.id };
       }
-      return { payload, id: context.id };
     },
 
     async set(key, value) {
@@ -168,20 +176,82 @@ function SQLiteFactory(params) {
       return this;
     }
   });
+
   // **
   // End definition if SQLite store
   // **
 
+  this.getOrCreateUserId = async function(chatId, transport, defaultUserId) {
+    // try to find a userId given then chatId / transport for the current chatbot
+    const binding = await ChatId.findOne({
+      where: { chatId, transport, chatbotId: this.chatbotId }
+    });
+
+    if (binding != null) {
+      return binding.userId;
+    } else {
+      const userId = !_.isEmpty(defaultUserId) ? defaultUserId : chatId;
+      await ChatId.create({ chatId, transport, chatbotId: this.chatbotId, userId });
+      return userId;
+    }
+  };
+
+  /**
+   * getUserId
+   * Get the userId from chatId, if doesn't exist, defaults to chatId
+   */
+  this.getUserId = async function(chatId, transport) {
+    const binding = await ChatId.findOne({
+      where: { chatId, transport, chatbotId: this.chatbotId }
+    });
+    return binding != null ? binding.userId : chatId;
+  };
+
+  this.getChatId = async function(userId, transport) {
+    const binding = await ChatId.findOne({
+      where: { userId, transport, chatbotId: this.chatbotId }
+    });
+    return binding != null ? binding.chatId : null;
+  };
+
+  this.getOrCreateContext = async function(userId, statics) {
+    if (isEmpty(userId)) {
+      return null;
+    }
+    // just create an class that just wraps userId, chatbotId and static value (cline)
+    const store = new SQLiteStore(userId, this.chatbotId, { ...statics });
+    return store;
+  };
+
+  this.mergeUserId = async function(fromUserId, toUserId) {
+    const fromChatIds = await ChatId.findAll({ where: { userId: fromUserId, chatbotId: this.chatbotId }});
+    const toChatIds = await ChatId.findAll({ where: { userId: toUserId, chatbotId: this.chatbotId }});
+
+    // turn only chatIds that don't already exists
+    for (const item of fromChatIds) {
+      const hasTransport = toChatIds.filter(({ transport }) => transport === item.transport).length !== 0;
+      if (!hasTransport) {
+        await ChatId.update({ userId: toUserId }, { where: { id: item.id }});
+      }
+    }
+  };
+
+  // deprecated below
+
   this.getOrCreate = async function(chatId, userId, statics) {
     if (isEmpty(chatId) && isEmpty(userId)) {
       return null;
     }
-    // just create an class that just wraps chatId and userId, add static value (cline)
-    const store = new SQLiteStore(chatId, userId, { ...statics });
+    // just create an class that just wraps userId, chatbotId and static value (cline)
+    const store = new SQLiteStore(userId, this.chatbotId, { ...statics });
     return store;
   };
   this.get = function(chatId, userId, statics) {
-    return new SQLiteStore(chatId, userId, statics);
+    console.warn('This is deprectated, use getContext instead')
+    return new SQLiteStore(userId, this.chatbotId, statics);
+  };
+  this.getContext = function(userId, statics) {
+    return new SQLiteStore(userId, this.chatbotId, statics);
   };
   this.assignToUser = async (userId, context) => {
   };
@@ -213,6 +283,7 @@ function SQLiteFactory(params) {
     try {
       if (createTable) {
         await Context.sync();
+        await ChatId.sync();
       }
       // then log, don't move, keep the log lines together
       console.log(lcd.timestamp() + 'SQLite context provider configuration:');
@@ -263,5 +334,4 @@ _.extend(SQLiteFactory.prototype, {
   }
 });
 
-
 module.exports = SQLiteFactory;

package/__tests__/context-provider-plain-file.js

@@ -1,174 +0,0 @@
-const _ = require('underscore');
-const assert = require('chai').assert;
-const RED = require('../lib/red-stub')();
-const ContextProviders = require('../chat-context-factory');
-const os = require('os');
-const fs = require('fs');
-const { when } = require('../lib/utils');
-
-
-describe('Chat context provider file', () => {
-
-  const contextProviders = ContextProviders(RED);
-  //const path = os.tmpdir();
-  const path = __dirname + '/test-files';
-  const provider = contextProviders.getProvider('plain-file', { path });
-
-  beforeEach(() => {
-    return provider.reset({ path });
-  });
-
-  afterAll(() => {
-    return provider.reset({ path });
-  });
-
-  it('should create a context provider with some default params', () => {
-
-    assert.isTrue(contextProviders.hasProvider('plain-file'));
-    const provider = contextProviders.getProvider('plain-file', { path });
-    assert.isFunction(provider.getOrCreate);
-    assert.isFunction(provider.get);
-
-    return when(provider.getOrCreate(42, null, { myVariable: 'initial value'}))
-      .then(chatContext => {
-        assert.isFunction(chatContext.get);
-        assert.isFunction(chatContext.set);
-        assert.isFunction(chatContext.all);
-        assert.isFunction(chatContext.remove);
-        assert.isFunction(chatContext.clear);
-        return chatContext.get('myVariable');
-      }).then(myVariable => {
-        assert.equal(myVariable, 'initial value');
-        // assert.isTrue(fs.existsSync(`${path}/store-7369f3c86bf3c0a354615432832d9e8f.json`));
-      });
-  });
-
-  it('should set some value and then get and remove it', async () => {
-    const chatContext = await provider.getOrCreate(42, null, {});
-    await chatContext.set('firstName', 'Guidone');
-    let firstName =await chatContext.get('firstName');
-    assert.equal(firstName, 'Guidone');
-    await chatContext.remove('firstName');
-    firstName = await chatContext.get('firstName');
-    assert.isUndefined(firstName);
-  });
-
-
-  it('should set some values and then get and remove it', async () => {
-    const chatContext = await provider.getOrCreate(42, null, {});
-    await chatContext.set({firstName: 'Guido', lastName: 'Bellomo'});
-    let firstName = await chatContext.get('firstName');
-    assert.equal(firstName, 'Guido');
-    let lastName = await chatContext.get('lastName');
-    assert.equal(lastName, 'Bellomo');
-    let json = await chatContext.get('firstName', 'lastName');
-    assert.isObject(json);
-    assert.equal(json.firstName, 'Guido');
-    assert.equal(json.lastName, 'Bellomo');
-  });
-
-  it('should set some values and then get and remove it with userId', async () => {
-    const chatContext = await provider.getOrCreate(null, 43, {});
-    await chatContext.set({ firstName: 'Guido', lastName: 'Bellomo' });
-    let firstName = await chatContext.get('firstName');
-    assert.equal(firstName, 'Guido');
-    let lastName = await chatContext.get('lastName');
-    assert.equal(lastName, 'Bellomo');
-    let json = await chatContext.get('firstName', 'lastName');
-    assert.isObject(json);
-    assert.equal(json.firstName, 'Guido');
-    assert.equal(json.lastName, 'Bellomo');
-  });
-
-  it('should set some values and get the dump with chatId', async () => {
-    const chatContext = await provider.getOrCreate(42, null, {});
-    await chatContext.set({firstName: 'Guido', lastName: 'Bellomo', email: 'spam@gmail.com'});
-    const json = await chatContext.all();
-    assert.isObject(json);
-    assert.equal(json.firstName, 'Guido');
-    assert.equal(json.lastName, 'Bellomo');
-    assert.equal(json.email, 'spam@gmail.com');
-  });
-
-  it('should set some values and get the dump with userId', async () => {
-    const chatContext = await provider.getOrCreate(null, 43, {});
-    await chatContext.set({firstName: 'Guido', lastName: 'Bellomo', email: 'spam@gmail.com'});
-    const json = await chatContext.all();
-    assert.isObject(json);
-    assert.equal(json.firstName, 'Guido');
-    assert.equal(json.lastName, 'Bellomo');
-    assert.equal(json.email, 'spam@gmail.com');
-  });
-
-  it('should set some values and remove all for chatId', async () => {
-    const chatContext = await provider.getOrCreate(42, {});
-    await chatContext.set({firstName: 'Guido', lastName: 'Bellomo'});
-    await chatContext.clear();
-    let firstName = await chatContext.get('firstName');
-    assert.isUndefined(firstName);
-    let lastName = await chatContext.get('lastName');
-    assert.isUndefined(lastName);
-    const json = await chatContext.all();
-    assert.isObject(json);
-    assert.isTrue(_.isEmpty(json));
-  });
-
-  it('should set some values and remove all for userId', async () => {
-    const chatContext = await provider.getOrCreate(null, 43,  {});
-    await chatContext.set({firstName: 'Guido', lastName: 'Bellomo'});
-    await chatContext.clear();
-    const firstName = await chatContext.get('firstName');
-    assert.isUndefined(firstName)
-    const lastName = await chatContext.get('lastName');
-    assert.isUndefined(lastName)
-    const json = await chatContext.all();
-    assert.isObject(json);
-    assert.isTrue(_.isEmpty(json));
-  });
-
-  it('should set some value the remove with multiple arguments for chatId', async () => {
-    const chatContext = await provider.getOrCreate(42, {});
-    await chatContext.set({firstName: 'Guidone', lastName: 'Bellomo', email: 'some@email'})
-    const firstName = await chatContext.get('firstName');
-    assert.equal(firstName, 'Guidone');
-    await chatContext.remove('firstName', 'lastName', 'email');
-    const json = await chatContext.all();
-    assert.isUndefined(json.firstName);
-    assert.isUndefined(json.lastName);
-    assert.isUndefined(json.email);
-  });
-
-  it('should set some value the remove with multiple arguments for userId', async () => {
-    const chatContext = await provider.getOrCreate(null, 43, {});
-    await chatContext.set({firstName: 'Guidone', lastName: 'Bellomo', email: 'some@email'});
-    const firstName = await chatContext.get('firstName');
-    assert.equal(firstName, 'Guidone');
-    await chatContext.remove('firstName', 'lastName', 'email');
-    const json = await chatContext.all();
-    assert.isUndefined(json.firstName);
-    assert.isUndefined(json.lastName);
-    assert.isUndefined(json.email);
-  });
-
-  it('should set some value with chatId and userId', async () => {
-    const chatContext = await provider.getOrCreate(42, 44, { userId: 44, chatId: 42 });
-    await chatContext.set('firstName', 'Guidone');
-    let firstName = await chatContext.get('firstName');
-    assert.equal(firstName, 'Guidone');
-    let userId = await chatContext.get('userId');
-    assert.equal(userId, 44);
-    let chatId = await chatContext.get('chatId');
-    assert.equal(chatId, 42);
-    const chatContext2 = await provider.getOrCreate(null, 44, { userId: 44, chatId: 42 });
-    firstName = await chatContext2.get('firstName');
-    assert.equal(firstName, 'Guidone');
-    userId = await chatContext2.get('userId');
-    assert.equal(userId, 44);
-    chatId = await chatContext2.get('chatId');
-    assert.equal(chatId, 42);
-    await chatContext2.remove('firstName');
-    firstName = await chatContext2.get('firstName');
-    assert.isUndefined(firstName);
-  });
-
-});