@mainframe/bot-sdk/README.md

# Mainframe JavaScript SDK for bots

- [Installation](#installation)
- [Example](#example)
- [Data types](#types)
- [API](#api)
  - [`createConfig`](#createconfig)
  - [`createContext`](#createcontext)
  - [`createRouter`](#createrouter)
  - [`createServer`](#createserver)
  - [`log`](#log)
  - [`startServer`](#startserver)
- [Usage](#usage)
  - [Basic usage](#basic-usage) - the easiest way to get started
  - [With custom route handlers](#adding-custom-route-handlers) - when you need custom routes
  - [Using an existing Express server](#using-an-existing-express-server) - giving you the flexibility to implement what you need
- [License](#license)

## Installation

```sh
npm install @mainframe/bot-sdk # npm
yarn add @mainframe/bot-sdk # Yarn
```

## Example

```js
const { startServer } = require('@mainframe/bot-sdk')

startServer(
  {
    conversation_added({ conversation_id }, { sendMessage }) {
      sendMessage({ conversation_id, message: 'Hello world' })
    },
  },
  {
    mainframe_secret: '<my bot secret>',
    port: 3000,
  },
)
```

## Types

The SDK uses the following [Flow types](https://flow.org/en/docs/types/):

```js
type PartialConfig = {
  +mainframe_secret: string,
  +mainframe_url: string,
  +port: number,
}

type Config = {|
  +mainframe_secret: string,
  +mainframe_url: string,
  +port: number,
|}

type ClientContext = {|
  +user: {
    +id: string,
    +username: string,
    +name: string,
  },
  +conversation?: {
    +id: string,
    +subject: ?string,
    +type: 'bot' | 'direct' | 'default' | 'space',
  },
  +organization?: {
    +id: string,
    +username: string,
    +name: string,
  },
  +subscription_token?: string,
|}

type PostPayload = {|
  +user_id: string,
  +data: Object,
  +context: ClientContext,
|}

type BotContext = {|
  +config: Config,
  +callMainframe: (endpoint: string, data?: Object) => Promise<void | Object>,
  +sendMessage: (payload: {
    conversation_id: string,
    message?: string,
    data?: Object,
  }) => Promise<void>,
  +createSubscription: (payload: {
    subscription_token: string,
    label?: string,
  }) => Promise<{ subscription_id: string }>,
  +editSubscription: (payload: {
    subscription_token: string,
    label?: string,
  }) => Promise<{ subscription_id: string }>,
|}

type BotResponse = {|
  success: boolean,
  message?: string,
  data?: Object,
|}

type Handlers = {|
  enable?: (payload: { user_id: string }) => void,
  disable?: (payload: { user_id: string }) => void,
  conversation_added?: (payload: {
    user_id: string,
    conversation_id: string,
  }) => void,
  conversation_removed?: (payload: {
    user_id: string,
    conversation_id: string,
  }) => void,
  edit_subscription?: (payload: {
    user_id: string,
    conversation_id: string,
    subscription_id: string,
  }) => void,
  delete_subscription?: (payload: { subscription_id: string }) => void,
  post?: (payload: PostRequest) => BotResponse | Promise<BotResponse>,
|}
```

## API

### createConfig

`createConfig (parameters?: PartialConfig): Config`

Creates the configuration using the provided parameters, environment variables or defaults.

### createContext

`createContext (config: Config): BotContext`

Creates a bot context provided to the handlers, notably to allow to communicate with Mainframe.

### createRouter

`createRouter (handlers: Handlers, context: BotContext): express$Router`

Creates an [Express Router](https://expressjs.com/en/4x/api.html#router) implementing HTTP endpoints for the provided handlers.

### createServer

`createServer (handlers: Handlers, config: Config): express$Application`

Creates an [Express Application](https://expressjs.com/en/4x/api.html#app) implementing HTTP endpoints for the provided handlers.

### log

`log (...args: Array<mixed>): void`

Logs using [debug](https://github.com/visionmedia/debug) with the `mainframe-bot` namespace.

### startServer

`startServer (handlers: Handlers, parameters?: PartialConfig): void`

Creates an [Express Application](https://expressjs.com/en/4x/api.html#app) implementing HTTP endpoints for the provided handlers and start listening using the `port` provided in `parameters`, defaulting to `4000`.

## Usage

### Basic usage

This SDK uses the [Express framework](https://expressjs.com/) to handle routing the provided handlers to the corresponding [HTTP endpoints used by the Mainframe server](http://developer.mainframe.com/#bot-api).  
All of these handlers are optional by default and you'll only need to implement them according to the needs of your bot.

The simplest way to get started it to call `startServer(handlers)`, for example:
```js
const { startServer } = require('@mainframe/bot-sdk')

startServer({
  conversation_added(payload, context) {
    context.sendMessage({
      conversation_id: payload.conversation_id,
      message: 'Hello world',
    })
  },
})
```

All handlers will be called with two arguments: an Object containing the request payload, and the [`BotContext`](types) notably allowing to make requests to Mainframe.

`startServer()` also supports providing a configuration Object as second argument, used to create the context. When not provided, the configuration will use the environment variables `MAINFRAME_SECRET`, `MAINFRAME_URL` and `PORT`.  
The configuration will by default use `https://api.mainframe.com/bots/v1` as Mainframe's API URL and listen on port `4000`.  
Your bot's `secret` **must be** provided, either directly as `mainframe_secret` in the configuration object, or in the `MAINFRAME_SECRET` environment variable.

### Adding custom route handlers

For more advanced use cases, you may want to create the Express server without listening right-away, this is possible using the `createServer(handlers, config)` function, that will return an [`Application Object`](https://expressjs.com/en/4x/api.html#app).  
This function expects a `config` Object providing all the configuration values. If you want to automatically use the environment variables or default configuration values, you can use `createConfig(optionalConfig)` that will use the values provided in `optionalConfig`, or default to the environment variables or predefined values.

Example:

```js
const { createConfig, createServer, log } = require('@mainframe/bot-sdk')

const config = createConfig({ mainframe_secret: '<your bot secret>' })
const server = createServer(
  {
    enable(payload) {
      log('enabled by user %s', payload.user_id)
    },
  },
  config,
)

server.get('/', (req, res) => {
  res.send('Hello')
})

server.listen(3000)
```

### Using an existing Express server

If you are already using Express and want to integrate the bot API with even more control, you can do so by using the `createRouter(handlers, context)`, that will return a [`Router instance`](https://expressjs.com/en/4x/api.html#router).  
This function requires a [`BotContext`](#types) to be provided as the second argument, that will be injected to the handlers when called. You can provide a custom implementation of the `context` if you have specific needs, or use `createContext(config)` to create it.

Example:

```js
const { createConfig, createContext, createRouter, log } = require('@mainframe/bot-sdk')
const express = require('express')

const app = express()

const config = createConfig() // Will use MAINFRAME_SECRET from the environment
const context = createContext(config)

const api = createRouter(
  {
    enable(payload) {
      log('enabled by user %s', payload.user_id)
    },
  },
  context,
)

app.use('/api', api)

app.all('*', (req, res) => {
  res.status(404).send('use /api')
})

app.listen(3000)
```

## License

MIT  
See [LICENSE file](LICENSE)