feat: Update README, tests, dependencies (#179)

 feat: Update README, tests, dependencies

Author: germanattanasio

.eslintignore

@@ -1,2 +1,2 @@
-lib/middleware/*.js
-lib/middleware/*.d.ts
+lib
+examples

.eslintrc.yml

@@ -1,30 +1,25 @@
 env:
   es6: true
   node: true
-  mocha: true
-extends: 'plugin:@typescript-eslint/recommended'
+  jest: true
+extends: 
+- 'plugin:@typescript-eslint/recommended'
+- 'prettier/@typescript-eslint'
+- 'plugin:prettier/recommended'
+
 parser: '@typescript-eslint/parser'
 parserOptions:
   project: './tsconfig.json'
 plugins:
   - '@typescript-eslint'
 rules:
-  indent:
-    - error
-    - 2
-  linebreak-style:
-    - error
-    - unix
-  quotes:
-    - error
-    - single
-  semi:
-    - error
-    - always
   no-console:
+    - warn
+  ' @typescript-eslint/no-explicit-any':
+    - warning
+  '@typescript-eslint/camelcase':
     - off
-  '@typescript-eslint/indent':
+  prettier/prettier:
     - error
-    - 2
-  ' @typescript-eslint/no-explicit-any':
-    - warning
+    - singleQuote: true
+

.npmignore

@@ -1,2 +1,3 @@
 examples
-test
+test
+src

.travis.yml

@@ -5,7 +5,10 @@ cache:
     - node_modules
 script:
   - npm run lint
-  - npm test
+  - npm test -- --coverage && codecov
+
+before_deploy:
+- npm run build
 deploy:
 - provider: script
   skip_cleanup: true

README.md

@@ -2,6 +2,31 @@
 
 This middleware plugin for [Botkit](http://howdy.ai/botkit) allows developers to easily integrate a [Watson Assistant](https://www.ibm.com/watson/ai-assistant/) workspace with multiple social channels like Slack, Facebook, and Twilio. Customers can have simultaneous, independent conversations with a single workspace through different channels.
 
+<details>
+  <summary>Table of Contents</summary>
+
+* [Middleware Overview](#middleware-overview)
+* [Function Overview](#function-overview)
+* [Installation](#installation)
+* [Prerequisites](#prerequisites)
+  + [Acquire channel credentials](#acquire-channel-credentials)
+  + [Bot setup](#bot-setup)
+* [Features](#features)
+  + [Message filtering](#message-filtering)
+    - [Using interpret function instead of registering middleware](#using-interpret-function-instead-of-registering-middleware)
+    - [Using middleware wrapper](#using-middleware-wrapper)
+  + [Minimum Confidence](#minimum-confidence)
+    - [Use it manually in your self-defined controller.hears() function(s)](#use-it-manually-in-your-self-defined-controllerhears-functions)
+    - [Use the middleware's hear() function](#use-the-middlewares-hear-function)
+  + [Implementing app actions](#implementing-app-actions)
+  + [Using sendToWatson to update context](#using-sendtowatson-to-update-context)
+* [Implementing event handlers](#implementing-event-handlers)
+  + [Intent matching](#intent-matching)
+    - [`before` and `after`](#before-and-after)
+    - [Dynamic workspace](#dynamic-workspace)
+
+</details>
+
 ## Middleware Overview
 
 * Automatically manages context in multi-turn conversations to keep track of where the user left off in the conversation.
@@ -25,20 +50,20 @@ This middleware plugin for [Botkit](http://howdy.ai/botkit) allows developers to
 ## Installation
 
 ```sh
-$ npm install botkit-middleware-watson --save
+$ npm install botkit-middleware-watson
 ```
 
 ## Prerequisites
 
-1. Sign up for an [IBM Cloud account](https://console.bluemix.net/registration/).
+1. Sign up for an [IBM Cloud account](https://cloud.ibm.com/registration/).
 1. Create an instance of the Watson Assistant service and get your credentials:
-    - Go to the [Watson Assistant](https://console.bluemix.net/catalog/services/conversation) page in the IBM Cloud Catalog.
+    - Go to the [Watson Assistant](https://cloud.ibm.com/catalog/services/conversation) page in the IBM Cloud Catalog.
     - Log in to your IBM Cloud account.
     - Click **Create**.
     - Copy the `apikey` value, or copy the `username` and `password` values if your service instance doesn't provide an `apikey`.
     - Copy the `url` value.
 
-1. Create a workspace using the Watson Assistant service and copy the `workspace_id`. If you don't know how to create a workspace follow the [Getting Started tutorial](https://console.bluemix.net/docs/services/conversation/getting-started.html).
+1. Create a workspace using the Watson Assistant service and copy the `workspace_id`. If you don't know how to create a workspace follow the [Getting Started tutorial](https://cloud.ibm.com/docs/services/conversation/getting-started.html).
 
 
 ### Acquire channel credentials
@@ -56,7 +81,7 @@ Otherwise, follow [Botkit's instructions](https://botkit.ai/docs/provisioning/sl
 This section walks you through code snippets to set up your Slack bot. If you want, you can jump straight to the [full example](/examples/simple-bot).
 
 In your app, add the following lines to create your Slack controller using Botkit:
-```typescript
+```js
 import { WatsonMiddleware } from 'botkit-middleware-watson';
 import Botkit = require('botkit');
 const { SlackAdapter } = require('botbuilder-adapter-slack');
@@ -78,7 +103,7 @@ Create the middleware object which you'll use to connect to the Watson Assistant
 
 If your credentials are `username` and `password` use:
 
-```typescript
+```js
 const watsonMiddleware = new WatsonMiddleware({
   username: YOUR_ASSISTANT_USERNAME,
   password: YOUR_ASSISTANT_PASSWORD,
@@ -91,7 +116,7 @@ const watsonMiddleware = new WatsonMiddleware({
 
 If your credentials is `apikey` use:
 
-```typescript
+```js
 const watsonMiddleware = new WatsonMiddleware({
   iam_apikey: YOUR_API_KEY,
   url: YOUR_ASSISTANT_URL,
@@ -102,12 +127,12 @@ const watsonMiddleware = new WatsonMiddleware({
 ```
 
 Tell your Slackbot to use the _watsonMiddleware_ for incoming messages:
-```typescript
+```js
 controller.middleware.receive.use(watsonMiddleware.receive.bind(watsonMiddleware));
 ```
 
 Finally, make your bot _listen_ to incoming messages and respond with Watson Assistant:
-```typescript
+```js
 controller.hears(['.*'], ['direct_message', 'direct_mention', 'mention'], async function(bot, message) {
   if (message.watsonError) {
     await  bot.reply(message, "I'm sorry, but for technical reasons I can't respond to your message");
@@ -131,21 +156,20 @@ If you would like to make your bot to only respond to _direct messages_ using As
 #### Using interpret function instead of registering middleware
 
 ```js
-slackController.hears(['.*'], ['direct_message'], async function(bot, message) {
-  middleware.interpret(bot, message, function() {
-    if (message.watsonError) {
-      bot.reply(message, "I'm sorry, but for technical reasons I can't respond to your message");
-    } else {
-      bot.reply(message, message.watsonData.output.text.join('\n'));
-    }
-  });
+slackController.hears(['.*'], ['direct_message'], async (bot, message) => {
+  await middleware.interpret(bot, message)
+  if (message.watsonError) {
+    bot.reply(message, "I'm sorry, but for technical reasons I can't respond to your message");
+  } else {
+    bot.reply(message, message.watsonData.output.text.join('\n'));
+  }
 });
 ```
 
 #### Using middleware wrapper
 
 ```js
-const receiveMiddleware = function (bot, message, next) {
+const receiveMiddleware = (bot, message, next) => {
   if (message.type === 'direct_message') {
     watsonMiddleware.receive(bot, message, next);
   } else {
@@ -164,7 +188,7 @@ To use the setup parameter `minimum_confidence`, you have multiple options:
 
 For example:
 ```js
-controller.hears(['.*'], ['direct_message', 'direct_mention', 'mention', 'message_received'], async function(bot, message) {
+controller.hears(['.*'], ['direct_message', 'direct_mention', 'mention', 'message_received'], async (bot, message) => {
   if (message.watsonError) {
     await bot.reply(message, "Sorry, there are technical problems.");     // deal with watson error
   } else {
@@ -180,6 +204,7 @@ controller.hears(['.*'], ['direct_message', 'direct_mention', 'mention', 'messag
 ```
 
 #### Use the middleware's hear() function
+
 You can find the default implementation of this function [here](https://github.com/watson-developer-cloud/botkit-middleware/blob/e29b002f2a004f6df57ddf240a3fdf8cb28f95d0/lib/middleware/index.js#L40). If you want, you can redefine this function in the same way that watsonMiddleware.before and watsonMiddleware.after can be redefined. Refer to the [Botkit Middleware documentation](https://botkit.ai/docs/core.html#controllerhears) for an example. Then, to use this function instead of Botkit's default pattern matcher (that does not use minimum_confidence), plug it in using:
 ```js
 controller.changeEars(watsonMiddleware.hear)
@@ -189,7 +214,7 @@ Note: if you want your own `hear()` function to implement pattern matching like
 
 ### Implementing app actions
 
-Watson Assistant side of app action is documented in [Developer Cloud](https://console.bluemix.net/docs/services/assistant/deploy-custom-app.html#deploy-custom-app)
+Watson Assistant side of app action is documented in [Developer Cloud](https://cloud.ibm.com/docs/services/assistant/deploy-custom-app.html#deploy-custom-app)
 A common scenario of processing actions is:
 
 * Send message to user "Please wait while I ..."
@@ -198,21 +223,19 @@ A common scenario of processing actions is:
 * Send message to Watson with updated context
 * Send result message(s) to user.
 
-### using sendToWatson to update context (possible since v1.5.0)
+### Using sendToWatson to update context
 
 Using sendToWatson to update context simplifies the bot code compared to solution using updateContext below.
 
-```typescript
-function checkBalance(context, callback) {
+```js
+const checkBalance =  async (context) => {
   //do something real here
   const contextDelta = {
     validAccount: true,
     accountBalance: 95.33
   };
-  callback(null, context);
-}
-
-const checkBalanceAsync = Promise.promisify(checkBalance);
+  return context;
+});
 
 const processWatsonResponse = async (bot, message) => {
   if (message.watsonError) {
@@ -227,12 +250,11 @@ const processWatsonResponse = async (bot, message) => {
       newMessage.text = 'balance result';
 
       try {
-        const contextDelta = await checkBalanceAsync(message.watsonData.context);
-        await watsonMiddleware.sendToWatsonAsync(bot, newMessage, contextDelta);
-      }catch(error) {
+        const contextDelta = await checkBalance(message.watsonData.context);
+        await watsonMiddleware.sendToWatson(bot, newMessage, contextDelta);
+      } catch(error) {
         newMessage.watsonError = error;
       }
-      
       return await processWatsonResponse(bot, newMessage);
     }
   }
@@ -245,34 +267,25 @@ controller.on('message_received', processWatsonResponse);
 
 Events are messages having type different than `message`.
 
-[Example](https://github.com/howdyai/botkit/blob/master/examples/facebook_bot.js) of handler:
+[Example](https://github.com/howdyai/botkit/blob/master/packages/docs/reference/facebook.md#facebookeventtypemiddleware) of handler:
+
 ```js
-controller.on('facebook_postback', function(bot, message) {
- bot.reply(message, 'Great Choice!!!! (' + message.payload + ')');
+controller.on('facebook_postback', async (bot, message) => {
+ await bot.reply(message, `Great Choice. (${message.payload})`);
 });
 ```
+
 Since they usually have no text, events aren't processed by middleware and have no watsonData attribute.
 If event handler wants to make use of some data from context, it has to read it first.
 Example:
+
 ```js
-controller.on('facebook_postback', function(bot, message) {
-  watsonMiddleware.readContext(message.user, function(err, context) {
-    if (!context) {
-      context = {};
-    }
+controller.on('facebook_postback', async (bot, message) => {
+  const context = watsonMiddleware.readContext(message.user);
     //do something useful here
-    myFunction(context.field1, context.field2, function(err, result) {
-      const newMessage = clone(message);
-      newMessage.text = 'postback result';
-
-      watsonMiddleware.sendToWatson(bot, newMessage, {postbackResult: 'success'}, function(err) {
-        if (err) {
-          newMessage.watsonError = error;
-        }
-        processWatsonResponse(bot, newMessage);
-      });
-    });
-  });
+  const result = await myFunction(context.field1, context.field2);
+  const newMessage = {...message, text: 'postback result' };
+  await watsonMiddleware.sendToWatson(bot, newMessage, { postbackResult: 'success' });
 });
 ```
 
@@ -288,7 +301,7 @@ The `hear()` function can be used on individual handler functions, or can be use
 
 Used on an individual handler:
 
-```typescript
+```js
 slackController.hears(['hello'], ['direct_message', 'direct_mention', 'mention'], watsonMiddleware.hear, async function(bot, message) {
   await bot.reply(message, message.watsonData.output.text.join('\n'));
   // now do something special related to the hello intent
@@ -297,42 +310,42 @@ slackController.hears(['hello'], ['direct_message', 'direct_mention', 'mention']
 
 Used globally:
 
-```typescript
+```js
 slackController.changeEars(watsonMiddleware.hear.bind(watsonMiddleware));
 
-slackController.hears(['hello'], ['direct_message', 'direct_mention', 'mention'], function(bot, message) {
-  bot.reply(message, message.watsonData.output.text.join('\n'));
+slackController.hears(['hello'], ['direct_message', 'direct_mention', 'mention'], async (bot, message) => {
+  await bot.reply(message, message.watsonData.output.text.join('\n'));
   // now do something special related to the hello intent
 });
 ```
 
 #### `before` and `after`
 
-The _before_ and _after_ callbacks can be used to perform some tasks _before_ and _after_ Assistant is called. One may use it to modify the request/response payloads, execute business logic like accessing a database or making calls to external services.
+The _before_ and _after_ async calls can be used to perform some tasks _before_ and _after_ Assistant is called. One may use it to modify the request/response payloads, execute business logic like accessing a database or making calls to external services.
 
 They can be customized as follows:
 
 ```js
-middleware.before = function(message, assistantPayload, callback) {
-  // Code here gets executed before making the call to Assistant.
-  callback(null, customizedPayload);
+middleware.before = (message, assistantPayload) => async () => {
+   // Code here gets executed before making the call to Assistant.
+  return assistantPayload;
 }
 ```
 
 ```js
-  middleware.after = function(message, assistantResponse, callback) {
-    // Code here gets executed after the call to Assistant.
-    callback(null, assistantResponse);
-  }
+middleware.after = (message, assistantResponse) => async () => {
+  // Code here gets executed after the call to Assistant.
+  return assistantResponse;
+});
 ```
 
 #### Dynamic workspace
 
-If you need to make use of multiple workspaces in a single bot, workspace_id can be changed dynamically by setting workspace_id property in context.
+If you need to make use of multiple workspaces in a single bot, `workspace_id` can be changed dynamically by setting `workspace_id` property in context.
 
-Example of setting workspace_id to id provided as a property of hello message:
-```typescript
-async function handleHelloEvent(bot, message) {
+Example of setting `workspace_id` to id provided as a property of hello message:
+```js
+async handleHelloEvent = (bot, message) => {
   message.type = 'welcome';
   const contextDelta = {};
 
@@ -341,7 +354,7 @@ async function handleHelloEvent(bot, message) {
   }
 
   try {
-    watsonMiddleware.sendToWatsonAsync(bot, message, contextDelta);
+    await watsonMiddleware.sendToWatson(bot, message, contextDelta);
   } catch(error) {
     message.watsonError = error;
   }