Support Botkit 4

Author: Naktibalda

lib/middleware/index.d.ts

@@ -1,12 +1,7 @@
 import * as Botkit from 'botkit';
 import Bluebird = require('bluebird');
+import { Storage } from 'botbuilder-core';
 
-declare module 'botkit' {
-  interface Message {
-    watsonError?: Error | string;
-    watsonData?: WatsonMiddleware.Data;
-  }
-}
 
 declare namespace WatsonMiddleware {
   interface Data {
@@ -74,32 +69,28 @@ declare namespace WatsonMiddleware {
   interface Middleware {
     minimum_confidence: number;
     conversation: any;
-    storage: {
-      users: Botkit.Storage<Botkit.User>;
-      channels: Botkit.Storage<Botkit.Channel>;
-      teams: Botkit.Storage<Botkit.Team>;
-    };
-    hear: (patterns: string[], message: Botkit.Message) => boolean;
+    storage: Storage;
+    hear: (patterns: string[], message: Botkit.BotkitMessage) => boolean;
     before: (
-      message: Botkit.Message,
+      message: Botkit.BotkitMessage,
       payload: Payload,
       callback: (err: string | Error, payload: Payload) => void
     ) => void;
-    after: (message: Botkit.Message, response, callback) => void;
+    after: (message: Botkit.BotkitMessage, response, callback) => void;
     sendToWatson: (
-      bot: Botkit.Bot<any, Botkit.Message>,
-      message: Botkit.Message,
+      bot: Botkit.BotWorker,
+      message: Botkit.BotkitMessage,
       contextDelta: ContextDelta,
       next: () => void
     ) => void;
     receive: (
-      bot: Botkit.Bot<any, Botkit.Message>,
-      message: Botkit.Message,
+      bot: Botkit.BotWorker,
+      message: Botkit.BotkitMessage,
       next: () => void
     ) => void;
     interpret: (
-      bot: Botkit.Bot<any, Botkit.Message>,
-      message: Botkit.Message,
+      bot: Botkit.BotWorker,
+      message: Botkit.BotkitMessage,
       next: () => void
     ) => void;
     readContext: (
@@ -112,13 +103,13 @@ declare namespace WatsonMiddleware {
       callback: (err: string | Error | null, watsonResponse?: Data) => void
     ) => void;
     sendToWatsonAsync: (
-      bot: Botkit.Bot<any, Botkit.Message>,
-      message: Botkit.Message,
+      bot: Botkit.BotWorker,
+      message: Botkit.BotkitMessage,
       contextDelta: ContextDelta
     ) => Bluebird<void>;
     interpretAsync: (
-      bot: Botkit.Bot<any, Botkit.Message>,
-      message: Botkit.Message
+      bot: Botkit.BotWorker,
+      message: Botkit.BotkitMessage
     ) => Bluebird<void>;
     readContextAsync: (user: string) => Bluebird<Context>;
     updateContextAsync: (user: string, context: Context) => Bluebird<Data>;
@@ -136,7 +127,7 @@ declare namespace WatsonMiddleware {
     [index: string]: any;
   }
 
-  export function createWatsonMiddleware(config: MiddlewareConfig): Middleware;
+  export function factory(config: MiddlewareConfig): Middleware;
 }
 
-export = WatsonMiddleware.createWatsonMiddleware;
+export = WatsonMiddleware.factory;

lib/middleware/index.js

@@ -20,27 +20,20 @@ var AssistantV1 = require('ibm-watson/assistant/v1');
 var watsonUtils = require('./utils');
 var deepMerge = require('deepmerge');
 
-var readContext = Promise.promisify(watsonUtils.readContext);
-var updateContext = Promise.promisify(watsonUtils.updateContext);
+var readContext = watsonUtils.readContext;
+var updateContext = watsonUtils.updateContext;
 var postMessage = Promise.promisify(watsonUtils.postMessage);
 
 // These are initiated by Slack itself and not from the end-user. Won't send these to WCS.
 var ignoreType = ['presence_change', 'reconnect_url'];
 
-module.exports = function (config) {
+var factory = function (config) {
 
   if (!config) {
     throw new Error('Watson Assistant config parameters absent.');
   }
 
-  if (config.version_date) {
-    console.warn('"version_date" is deprecated and will be removed in the next major release. Use "version"');
-    config.version = config.version_date;
-    delete config.version_date;
-  }
-
   var middleware = {
-
     minimum_confidence: (config.minimum_confidence || 0.75),
 
     hear: function (patterns, message) {
@@ -66,15 +59,10 @@ module.exports = function (config) {
       callback(null, response);
     },
 
-    sendToWatson: function (bot, message, contextDelta, next) {
+    sendToWatsonAsync: function (bot, message, contextDelta) {
       var before = Promise.promisify(middleware.before);
       var after = Promise.promisify(middleware.after);
 
-      if (!next && typeof contextDelta === 'function') {
-        next = contextDelta;
-        contextDelta = null;
-      }
-
       if (!middleware.conversation) {
         debug('Creating Assistant object with parameters: ' + JSON.stringify(config, null, 2));
         middleware.conversation = new AssistantV1(config);
@@ -87,12 +75,12 @@ module.exports = function (config) {
             text: []
           }
         };
-        return next();
+        return Promise.resolve();
       }
 
-      middleware.storage = bot.botkit.storage;
+      middleware.storage = bot.controller.storage;
 
-      readContext(message.user, middleware.storage).then(function (userContext) {
+      return readContext(message.user, middleware.storage).then(function (userContext) {
         var payload = {
           workspace_id: config.workspace_id
         };
@@ -130,52 +118,55 @@ module.exports = function (config) {
       }).catch(function (error) {
         message.watsonError = error;
         debug('Error: %s', JSON.stringify(error, Object.getOwnPropertyNames(error), 2));
-      }).done(function () {
-        next();
       });
     }
   };
 
-  middleware.receive = function (bot, message, next) {
-    return middleware.sendToWatson(bot, message, null, next);
+  middleware.receiveAsync = function (bot, message) {
+    return middleware.sendToWatsonAsync(bot, message, null);
   };
 
-  middleware.interpret = middleware.receive;
+  middleware.interpretAsync = middleware.receiveAsync;
 
 
-  middleware.readContext = function (user, callback) {
+  middleware.readContextAsync = function (user) {
     if (!middleware.storage) {
-      return callback(new Error('readContext is called before the first middleware.receive call'));
+      throw new Error('readContext is called before the first middleware.receive call');
     }
-    return watsonUtils.readContext(user, middleware.storage, callback);
+    return watsonUtils.readContext(user, middleware.storage);
   };
 
-  middleware.updateContext = function (user, context, callback) {
+  middleware.updateContextAsync = function (user) {
     if (!middleware.storage) {
-      return callback(new Error('updateContext is called before the first middleware.receive call'));
+      throw new Error('updateContext is called before the first middleware.receive call');
     }
-    watsonUtils.updateContext(
+    return watsonUtils.updateContext(
       user,
       middleware.storage, {
         context: context
-      },
-      callback
+      }
     );
   };
 
-  middleware.interpretAsync = Promise.promisify(middleware.interpret, {
-    context: middleware
-  });
-  middleware.sendToWatsonAsync = Promise.promisify(middleware.sendToWatson, {
-    context: middleware
-  });
-  middleware.readContextAsync = Promise.promisify(middleware.readContext, {
-    context: middleware
-  });
-  middleware.updateContextAsync = Promise.promisify(middleware.updateContext, {
-    context: middleware
-  });
+  middleware.receive = middleware.interpret = function (bot, message, callback) {
+    return watsonUtils.asCallback(middleware.interpretAsync(bot, message), callback);
+  };
+  middleware.sendToWatson = function (bot, message, contextDelta, callback) {
+    if (!callback && typeof contextDelta === 'function') {
+      callback = contextDelta;
+      contextDelta = null;
+    }
+    return watsonUtils.asCallback(middleware.sendToWatsonAsync(bot, message, contextDelta), callback);
+  };
+  middleware.readContext = function (user, callback) {
+    return watsonUtils.asCallback(middleware.readContextAsync(user), callback);
+  };
+  middleware.updateContext = function (user, contextDelta, callback) {
+    return watsonUtils.asCallback(middleware.updateContextAsync(user, contextDelta), callback);
+  };
 
   debug('Middleware: ' + JSON.stringify(middleware, null, 2));
   return middleware;
 };
+
+module.exports = factory;

lib/middleware/utils.js

@@ -15,42 +15,41 @@
  */
 var debug = require('debug')('watson-middleware:utils');
 
-var readContext = function (userId, storage, callback) {
-  storage.users.get(userId, function (err, user_data) {
-    if (err) {
-      //error is returned if nothing is stored yet, so it is the best to ignore it
-      debug('User: %s, read context error: %s', userId, err);
-    }
+var storagePrefix = 'user.';
 
-    if (user_data && user_data.context) {
-      debug('User: %s, Context: %s', userId, JSON.stringify(user_data.context, null, 2));
-      callback(null, user_data.context);
-    } else {
-      debug('User: %s, Context: %s', userId, JSON.stringify(null));
-      callback(null, null);
+var readContext = function (userId, storage) {
+  var itemId = storagePrefix + userId;
+  return storage.read([itemId]).then(function(result) {
+    if (typeof result[itemId] !== 'undefined' && result[itemId].context) {
+      debug('User: %s, Context: %s', userId, JSON.stringify(result[itemId].context, null, 2));
+      return result[itemId].context;
     }
+    return null;
+  }).catch(function (err) {
+    debug('User: %s, read context error: %s', userId, err);
+    return null;
   });
 };
 
-var updateContext = function (userId, storage, watsonResponse, callback) {
-  storage.users.get(userId, function (err, user_data) {
-    if (err) {
-      //error is returned if nothing is stored yet, so it is the best to ignore it
-      debug('User: %s, read context error: %s', userId, err);
+var updateContext = function (userId, storage, watsonResponse) {
+  var itemId = storagePrefix + userId;
+  return storage.read([itemId]).then(function(result) {
+    if (typeof result[itemId] !== 'undefined') {
+      debug('User: %s, Data: %s', userId, JSON.stringify(result[itemId], null, 2));
+      return result[itemId];
     }
-
-    if (!user_data) {
-      user_data = {};
+    return null;
+  }).then(function (userData) {
+    if (userData == null) {
+      userData = {};
     }
-    user_data.id = userId;
-    user_data.context = watsonResponse.context;
-
-    storage.users.save(user_data, function (err) {
-      if (err) return callback(err);
-
-      debug('User: %s, Updated Context: %s', userId, JSON.stringify(watsonResponse.context, null, 2));
-      callback(null, watsonResponse);
-    });
+    userData.id = userId;
+    userData.context = watsonResponse.context;
+    var changes = {};
+    changes[itemId] = userData;
+    return storage.write(changes);
+  }).then(function () {
+    return watsonResponse;
   });
 };
 
@@ -64,8 +63,23 @@ var postMessage = function (conversation, payload, callback) {
     .catch(callback);
 };
 
+var asCallback = function (promise, cb) {
+  if (typeof cb !== 'function') {
+    cb = function() {};
+  }
+
+  return promise.then((result) => {
+    cb(null, result);
+    return promise;
+  }).catch((err) => {
+    cb(err);
+    return promise;
+  });
+};
+
 module.exports = {
   readContext: readContext,
   updateContext: updateContext,
-  postMessage: postMessage
-};
+  postMessage: postMessage,
+  asCallback: asCallback
+};